home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / dbxread.c < prev    next >
C/C++ Source or Header  |  1992-04-27  |  81KB  |  2,933 lines
  1. /* Read dbx symbol tables and convert to internal format, for GDB.
  2.    Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include "param.h"
  22.  
  23. #ifdef READ_DBX_FORMAT
  24.  
  25. #ifdef atarist
  26. #include <gnu-out.h>
  27. int gcc_mshort = 0;
  28. #else
  29. #include <a.out.h>
  30. #endif
  31.  
  32. #include <stab.h>
  33. #include <stdio.h>
  34. #include <obstack.h>
  35.  
  36. #ifdef atarist
  37. /* #include <param.h> */
  38. #include <file.h>
  39. #include <types.h>
  40. #include <stat.h>
  41. #else
  42. #include <sys/param.h>
  43. #include <sys/file.h>
  44. #include <sys/stat.h>
  45. #endif
  46.  
  47. #include "defs.h"
  48. #include "symtab.h"
  49.  
  50. static void add_symbol_to_list ();
  51. static void read_dbx_symtab ();
  52. static void process_one_symbol ();
  53. static struct type *read_type ();
  54. static struct type *read_range_type ();
  55. static struct type *read_enum_type ();
  56. static struct type *read_struct_type ();
  57. static struct type *read_array_type ();
  58.  
  59. static long read_number ();
  60. static void finish_block ();
  61. static struct blockvector *make_blockvector ();
  62. static struct symbol *define_symbol ();
  63. static void start_subfile ();
  64. static int hashname ();
  65.  
  66. static void add_undefined_type ();
  67. static void cleanup_undefined_types ();
  68.  
  69. extern struct symtab *read_symsegs ();
  70. extern void free_all_symtabs ();
  71.  
  72. /* Macro for number of symbol table entries (in usual a.out format).
  73.    Some machines override this definition.  */
  74. #ifndef NUMBER_OF_SYMBOLS
  75. #define NUMBER_OF_SYMBOLS (hdr.a_syms / sizeof (struct nlist))
  76. #endif
  77.  
  78. /* Macro for file-offset of symbol table (in usual a.out format).  */
  79. #ifndef SYMBOL_TABLE_OFFSET
  80. #define SYMBOL_TABLE_OFFSET N_SYMOFF (hdr)
  81. #endif
  82.  
  83. /* Macro for file-offset of string table (in usual a.out format).  */
  84. #ifndef STRING_TABLE_OFFSET
  85. #define STRING_TABLE_OFFSET (N_SYMOFF (hdr) + hdr.a_syms)
  86. #endif
  87.  
  88. /* Macro to store the length of the string table data in INTO.  */
  89. #ifndef READ_STRING_TABLE_SIZE
  90. #define READ_STRING_TABLE_SIZE(INTO)        \
  91. { val = myread (desc, &INTO, sizeof INTO);    \
  92.   if (val < 0) perror_with_name (name); }
  93. #endif
  94.  
  95. /* Macro to declare variables to hold the file's header data.  */
  96. #ifndef DECLARE_FILE_HEADERS
  97. #define DECLARE_FILE_HEADERS  struct exec hdr
  98. #endif
  99.  
  100. /* Macro to read the header data from descriptor DESC and validate it.
  101.    NAME is the file name, for error messages.  */
  102. #ifndef READ_FILE_HEADERS
  103. #define READ_FILE_HEADERS(DESC, NAME)        \
  104. { val = myread (DESC, &hdr, sizeof hdr);    \
  105.   if (val < 0) perror_with_name (NAME);        \
  106.   if (N_BADMAG (hdr))                \
  107.     error ("File \"%s\" not in executable format.", NAME); }
  108. #endif
  109.  
  110. /* Chain of symtabs made from reading the file's symsegs.
  111.    These symtabs do not go into symtab_list themselves,
  112.    but the information is copied from them when appropriate
  113.    to make the symtabs that will exist permanently.  */
  114.  
  115. /* Name of source file whose symbol data we are now processing.
  116.    This comes from a symbol of type N_SO.  */
  117.  
  118. static char *last_source_file;
  119.  
  120. /* Core address of start of text of current source file.
  121.    This too comes from the N_SO symbol.  */
  122.  
  123. static CORE_ADDR last_source_start_addr;
  124.  
  125. /* End of the text segment of the executable file,
  126.    as found in the symbol _etext.  */
  127.  
  128. CORE_ADDR end_of_text_addr;
  129.  
  130. /* The list of sub-source-files within the current individual compilation.
  131.    Each file gets its own symtab with its own linetable and associated info,
  132.    but they all share one blockvector.  */
  133.  
  134. struct subfile
  135. {
  136.   struct subfile *next;
  137.   char *name;
  138.   struct linetable *line_vector;
  139.   int line_vector_length;
  140.   int line_vector_index;
  141.   int prev_line_number;
  142. };
  143.  
  144. static struct subfile *subfiles;
  145.  
  146. static struct subfile *current_subfile;
  147.  
  148. /* Count symbols as they are processed, for error messages.  */
  149.  
  150. static int symnum;
  151.  
  152. /* Vector of types defined so far, indexed by their dbx type numbers.
  153.    (In newer sun systems, dbx uses a pair of numbers in parens,
  154.     as in "(SUBFILENUM,NUMWITHINSUBFILE)".  Then these numbers must be
  155.     translated through the type_translations hash table to get
  156.     the index into the type vector.)  */
  157.  
  158. static struct typevector *type_vector;
  159.  
  160. /* Number of elements allocated for type_vector currently.  */
  161.  
  162. static int type_vector_length;
  163.  
  164. /* Vector of line number information.  */
  165.  
  166. static struct linetable *line_vector;
  167.  
  168. /* Index of next entry to go in line_vector_index.  */
  169.  
  170. static int line_vector_index;
  171.  
  172. /* Last line number recorded in the line vector.  */
  173.  
  174. static int prev_line_number = -2;
  175.  
  176. /* Number of elements allocated for line_vector currently.  */
  177.  
  178. static int line_vector_length;
  179.  
  180. /* Hash table of global symbols whose values are not known yet.
  181.    They are chained thru the SYMBOL_VALUE, since we don't
  182.    have the correct data for that slot yet.  */
  183.  
  184. #define HASHSIZE 127
  185. static struct symbol *global_sym_chain[HASHSIZE];
  186.  
  187. /* Record the symbols defined for each context in a list.
  188.    We don't create a struct block for the context until we
  189.    know how long to make it.  */
  190.  
  191. #define PENDINGSIZE 100
  192.  
  193. struct pending
  194. {
  195.   struct pending *next;
  196.   int nsyms;
  197.   struct symbol *symbol[PENDINGSIZE];
  198. };
  199.  
  200. /* List of free `struct pending' structures for reuse.  */
  201. struct pending *free_pendings;
  202.  
  203. /* Here are the three lists that symbols are put on.  */
  204.  
  205. struct pending *file_symbols;    /* static at top level, and types */
  206.  
  207. struct pending *global_symbols;    /* global functions and variables */
  208.  
  209. struct pending *local_symbols;    /* everything local to lexical context */
  210.  
  211. /* Stack representing unclosed lexical contexts
  212.    (that will become blocks, eventually).  */
  213.  
  214. struct context_stack
  215. {
  216.   struct pending *locals;
  217.   struct pending_block *old_blocks;
  218.   struct symbol *name;
  219.   CORE_ADDR start_addr;
  220.   int depth;
  221. };
  222.  
  223. struct context_stack *context_stack;
  224.  
  225. /* Index of first unused entry in context stack.  */
  226. int context_stack_depth;
  227.  
  228. /* Currently allocated size of context stack.  */
  229.  
  230. int context_stack_size;
  231.  
  232. /* Nonzero if within a function (so symbols should be local,
  233.    if nothing says specifically).  */
  234.  
  235. int within_function;
  236.  
  237. /* List of blocks already made (lexical contexts already closed).
  238.    This is used at the end to make the blockvector.  */
  239.  
  240. struct pending_block
  241. {
  242.   struct pending_block *next;
  243.   struct block *block;
  244. };
  245.  
  246. struct pending_block *pending_blocks;
  247.  
  248. /* Make a list of forward references which haven't been defined.  */
  249. static struct type **undef_types;
  250. static int undef_types_allocated, undef_types_length;
  251.  
  252. extern CORE_ADDR first_object_file_end;    /* From blockframe.c */
  253.  
  254. /* File name symbols were loaded from.  */
  255.  
  256. static char *symfile;
  257.  
  258. extern char *xmalloc();
  259. #define xxmalloc xmalloc
  260.  
  261. /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
  262.    (and add a null character at the end in the copy).
  263.    Returns the address of the copy.  */
  264.  
  265. static char *
  266. obsavestring (ptr, size)
  267.      char *ptr;
  268.      int size;
  269. {
  270.   register char *p = (char *) obstack_alloc (symbol_obstack, size + 1);
  271.   /* Open-coded bcopy--saves function call time.
  272.      These strings are usually short.  */
  273.   {
  274.     register char *p1 = ptr;
  275.     register char *p2 = p;
  276.     char *end = ptr + size;
  277.     while (p1 != end)
  278.       *p2++ = *p1++;
  279.   }
  280.   p[size] = 0;
  281.   return p;
  282. }
  283.  
  284. /* Concatenate strings S1, S2 and S3; return the new string.
  285.    Space is found in the symbol_obstack.  */
  286.  
  287. static char *
  288. obconcat (s1, s2, s3)
  289.      char *s1, *s2, *s3;
  290. {
  291.   register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
  292.   register char *val = (char *) obstack_alloc (symbol_obstack, len);
  293.   strcpy (val, s1);
  294.   strcat (val, s2);
  295.   strcat (val, s3);
  296.   return val;
  297. }
  298.  
  299. /* Support for Sun changes to dbx symbol format */
  300.  
  301. /* For each identified header file, we have a table of types defined
  302.    in that header file.
  303.  
  304.    header_files maps header file names to their type tables.
  305.    It is a vector of n_header_files elements.
  306.    Each element describes one header file.
  307.    It contains a vector of types.
  308.  
  309.    Sometimes it can happen that the same header file produces
  310.    different results when included in different places.
  311.    This can result from conditionals or from different
  312.    things done before including the file.
  313.    When this happens, there are multiple entries for the file in this table,
  314.    one entry for each distinct set of results.
  315.    The entries are distinguished by the INSTANCE field.
  316.    The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
  317.    used to match header-file references to their corresponding data.  */
  318.  
  319. struct header_file
  320. {
  321.   char *name;            /* Name of header file */
  322.   int instance;            /* Numeric code distinguishing instances
  323.                    of one header file that produced
  324.                    different results when included.
  325.                    It comes from the N_BINCL or N_EXCL.  */
  326.   struct type **vector;        /* Pointer to vector of types */
  327.   int length;            /* Allocated length (# elts) of that vector */
  328. };
  329.  
  330. static struct header_file *header_files;
  331.  
  332. static int n_header_files;
  333.  
  334. static int n_allocated_header_files;
  335.  
  336. /* Within each object file, various header files are assigned numbers.
  337.    A type is defined or referred to with a pair of numbers
  338.    (FILENUM,TYPENUM) where FILENUM is the number of the header file
  339.    and TYPENUM is the number within that header file.
  340.    TYPENUM is the index within the vector of types for that header file.
  341.  
  342.    FILENUM == 1 is special; it refers to the main source of the object file,
  343.    and not to any header file.  FILENUM != 1 is interpreted by looking it up
  344.    in the following table, which contains indices in header_files.  */
  345.  
  346. static int *this_object_header_files;
  347.  
  348. static int n_this_object_header_files;
  349.  
  350. static int n_allocated_this_object_header_files;
  351.  
  352. /* When a header file is getting special overriding definitions
  353.    for one source file, record here the header_files index
  354.    of its normal definition vector.
  355.    At other times, this is -1.  */
  356.  
  357. static int header_file_prev_index;
  358.  
  359. /* At the start of reading dbx symbols, allocate our tables.  */
  360.  
  361. static void
  362. init_header_files ()
  363. {
  364.   n_allocated_header_files = 10;
  365.   header_files = (struct header_file *) xxmalloc (10 * sizeof (struct header_file));
  366.   n_header_files = 0;
  367.  
  368.   n_allocated_this_object_header_files = 10;
  369.   this_object_header_files = (int *) xxmalloc (10 * sizeof (int));
  370. }
  371.  
  372. /* At the end of reading dbx symbols, free our tables.  */
  373.  
  374. static void
  375. free_header_files ()
  376. {
  377.   register int i;
  378.   for (i = 0; i < n_header_files; i++)
  379.     free (header_files[i].name);
  380.   if (header_files) free (header_files);
  381.   if (this_object_header_files)
  382.     free (this_object_header_files);
  383. }
  384.  
  385. /* Called at the start of each object file's symbols.
  386.    Clear out the mapping of header file numbers to header files.  */
  387.  
  388. static void
  389. new_object_header_files ()
  390. {
  391.   /* Leave FILENUM of 0 free for builtin types and this file's types.  */
  392.   n_this_object_header_files = 1;
  393.   header_file_prev_index = -1;
  394. }
  395.  
  396. /* Add header file number I for this object file
  397.    at the next successive FILENUM.  */
  398.  
  399. static void
  400. add_this_object_header_file (i)
  401.      int i;
  402. {
  403.   if (n_this_object_header_files == n_allocated_this_object_header_files)
  404.     {
  405.       n_allocated_this_object_header_files *= 2;
  406.       this_object_header_files
  407.     = (int *) xrealloc (this_object_header_files,
  408.                 n_allocated_this_object_header_files * sizeof (int));
  409.     }
  410.  
  411.   this_object_header_files[n_this_object_header_files++] = i;
  412. }
  413.  
  414. /* Add to this file an "old" header file, one already seen in
  415.    a previous object file.  NAME is the header file's name.
  416.    INSTANCE is its instance code, to select among multiple
  417.    symbol tables for the same header file.  */
  418.  
  419. static void
  420. add_old_header_file (name, instance)
  421.      char *name;
  422.      int instance;
  423. {
  424.   register struct header_file *p = header_files;
  425.   register int i;
  426.  
  427.   for (i = 0; i < n_header_files; i++)
  428.     if (!strcmp (p[i].name, name) && instance == p[i].instance)
  429.       {
  430.     add_this_object_header_file (i);
  431.     return;
  432.       }
  433.   error ("Invalid symbol data: \"repeated\" header file that hasn't been seen before, at symtab pos %d.",
  434.      symnum);
  435. }
  436.  
  437. /* Add to this file a "new" header file: definitions for its types follow.
  438.    NAME is the header file's name.
  439.    Most often this happens only once for each distinct header file,
  440.    but not necessarily.  If it happens more than once, INSTANCE has
  441.    a different value each time, and references to the header file
  442.    use INSTANCE values to select among them.
  443.  
  444.    dbx output contains "begin" and "end" markers for each new header file,
  445.    but at this level we just need to know which files there have been;
  446.    so we record the file when its "begin" is seen and ignore the "end".  */
  447.  
  448. static void
  449. add_new_header_file (name, instance)
  450.      char *name;
  451.      int instance;
  452. {
  453.   register int i;
  454.   register struct header_file *p = header_files;
  455.   header_file_prev_index = -1;
  456.  
  457. #if 0
  458.   /* This code was used before I knew about the instance codes.
  459.      My first hypothesis is that it is not necessary now
  460.      that instance codes are handled.  */
  461.  
  462.   /* Has this header file a previous definition?
  463.      If so, make a new entry anyway so that this use in this source file
  464.      gets a separate entry.  Later source files get the old entry.
  465.      Record here the index of the old entry, so that any type indices
  466.      not previously defined can get defined in the old entry as
  467.      well as in the new one.  */
  468.  
  469.   for (i = 0; i < n_header_files; i++)
  470.     if (!strcmp (p[i].name, name))
  471.       {
  472.     header_file_prev_index = i;
  473.       }
  474.  
  475. #endif
  476.  
  477.   /* Make sure there is room for one more header file.  */
  478.  
  479.   if (n_header_files == n_allocated_header_files)
  480.     {
  481.       n_allocated_header_files *= 2;
  482.       header_files
  483.     = (struct header_file *) xrealloc (header_files, n_allocated_header_files * sizeof (struct header_file));
  484.     }
  485.  
  486.   /* Create an entry for this header file.  */
  487.  
  488.   i = n_header_files++;
  489.   header_files[i].name = savestring (name, strlen(name));
  490.   header_files[i].instance = instance;
  491.   header_files[i].length = 10;
  492.   header_files[i].vector
  493.     = (struct type **) xxmalloc (10 * sizeof (struct type *));
  494.   bzero (header_files[i].vector, 10 * sizeof (struct type *));
  495.  
  496.   add_this_object_header_file (i);
  497. }
  498.  
  499. /* Look up a dbx type-number pair.  Return the address of the slot
  500.    where the type for that number-pair is stored.
  501.    The number-pair is in TYPENUMS.
  502.  
  503.    This can be used for finding the type associated with that pair
  504.    or for associating a new type with the pair.  */
  505.  
  506. static struct type **
  507. dbx_lookup_type (typenums)
  508.      int typenums[2];
  509. {
  510.   register int filenum = typenums[0], Index = typenums[1];
  511.  
  512.   if (filenum < 0 || filenum >= n_this_object_header_files)
  513.     error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
  514.        filenum, Index, symnum);
  515.  
  516.   if (filenum == 0)
  517.     {
  518.       /* Type is defined outside of header files.
  519.      Find it in this object file's type vector.  */
  520.       while (Index >= type_vector_length)
  521.     {
  522.       type_vector_length *= 2;
  523.       type_vector = (struct typevector *)
  524.         xrealloc (type_vector, sizeof (struct typevector) + type_vector_length * sizeof (struct type *));
  525.       bzero (&type_vector->type[type_vector_length / 2],
  526.          type_vector_length * sizeof (struct type *) / 2);
  527.     }
  528.       return &type_vector->type[Index];
  529.     }
  530.   else
  531.     {
  532.       register int real_filenum = this_object_header_files[filenum];
  533.       register struct header_file *f;
  534.       int f_orig_length;
  535.  
  536.       if (real_filenum >= n_header_files)
  537.     abort ();
  538.  
  539.       f = &header_files[real_filenum];
  540.  
  541.       f_orig_length = f->length;
  542.       if (Index >= f_orig_length)
  543.     {
  544.       while (Index >= f->length)
  545.         f->length *= 2;
  546.       f->vector = (struct type **)
  547.         xrealloc (f->vector, f->length * sizeof (struct type *));
  548.       bzero (&f->vector[f_orig_length],
  549.          (f->length - f_orig_length) * sizeof (struct type *));
  550.     }
  551.       return &f->vector[Index];
  552.     }
  553. }
  554. /* Create a type object.  Occaisionally used when you need a type
  555.    which isn't going to be given a type number.  */
  556.  
  557. static struct type *
  558. dbx_create_type ()
  559. {
  560.   register struct type *type =
  561.     (struct type *) obstack_alloc (symbol_obstack, sizeof (struct type));
  562.  
  563.   bzero (type, sizeof (struct type));
  564. #if 0
  565.   TYPE_VPTR_FIELDNO (type) = -1;
  566. #endif
  567.   return type;
  568. }
  569.  
  570. /* Make sure there is a type allocated for type numbers TYPENUMS
  571.    and return the type object.
  572.    This can create an empty (zeroed) type object.  */
  573.  
  574. static struct type *
  575. dbx_alloc_type (typenums)
  576.      int typenums[2];
  577. {
  578.   register struct type **type_addr;
  579.   register struct type *type;
  580.  
  581.   if (typenums[1] != -1)
  582.     {
  583.       type_addr = dbx_lookup_type (typenums);
  584.       type = *type_addr;
  585.     }
  586.   else
  587.     {
  588.       type_addr = 0;
  589.       type = 0;
  590.     }
  591.  
  592.   /* If we are referring to a type not known at all yet,
  593.      allocate an empty type for it.
  594.      We will fill it in later if we find out how.  */
  595.   if (type == 0)
  596.     {
  597.       type = dbx_create_type ();
  598.       if (type_addr)
  599.     *type_addr = type;
  600.     }
  601.   
  602.   return type;
  603. }
  604.  
  605. #if 0
  606. static struct type **
  607. explicit_lookup_type (real_filenum, index)
  608.      int real_filenum, index;
  609. {
  610.   register struct header_file *f = &header_files[real_filenum];
  611.  
  612.   if (index >= f->length)
  613.     {
  614.       f->length *= 2;
  615.       f->vector = (struct type **)
  616.     xrealloc (f->vector, f->length * sizeof (struct type *));
  617.       bzero (&f->vector[f->length / 2],
  618.          f->length * sizeof (struct type *) / 2);
  619.     }
  620.   return &f->vector[index];
  621. }
  622. #endif
  623.  
  624. /* maintain the lists of symbols and blocks */
  625.  
  626. /* Add a symbol to one of the lists of symbols.  */
  627. static void
  628. add_symbol_to_list (symbol, listhead)
  629.      struct symbol *symbol;
  630.      struct pending **listhead;
  631. {
  632.   /* We keep PENDINGSIZE symbols in each link of the list.
  633.      If we don't have a link with room in it, add a new link.  */
  634.   if (*listhead == 0 || (*listhead)->nsyms == PENDINGSIZE)
  635.     {
  636.       register struct pending *link;
  637.       if (free_pendings)
  638.     {
  639.       link = free_pendings;
  640.       free_pendings = link->next;
  641.     }
  642.       else
  643.     link = (struct pending *) xxmalloc (sizeof (struct pending));
  644.  
  645.       link->next = *listhead;
  646.       *listhead = link;
  647.       link->nsyms = 0;
  648.     }
  649.  
  650.   (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
  651. }
  652.  
  653. /* At end of reading syms, or in case of quit,
  654.    really free as many `struct pending's as we can easily find.  */
  655.  
  656. static void
  657. really_free_pendings ()
  658. {
  659.   struct pending *next, *next1;
  660.   struct pending_block *bnext, *bnext1;
  661.  
  662.   for (next = free_pendings; next; next = next1)
  663.     {
  664.       next1 = next->next;
  665.       free (next);
  666.     }
  667.   free_pendings = 0;
  668.  
  669. #if 0 /* Now we make the links in the symbol_obstack, so don't free them.  */
  670.   for (bnext = pending_blocks; bnext; bnext = bnext1)
  671.     {
  672.       bnext1 = bnext->next;
  673.       free (bnext);
  674.     }
  675. #endif
  676.   pending_blocks = 0;
  677.  
  678.   for (next = file_symbols; next; next = next1)
  679.     {
  680.       next1 = next->next;
  681.       free (next);
  682.     }
  683.   file_symbols = 0;
  684.   
  685.   for (next = global_symbols; next; next = next1)
  686.     {
  687.       next1 = next->next;
  688.       free (next);
  689.     }
  690.   global_symbols = 0;
  691.   
  692. }
  693.  
  694. /* Take one of the lists of symbols and make a block from it.
  695.    Keep the order the symbols have in the list (reversed from the input file).
  696.    Put the block on the list of pending blocks.  */
  697.  
  698. static void
  699. finish_block (symbol, listhead, old_blocks, start, end)
  700.      struct symbol *symbol;
  701.      struct pending **listhead;
  702.      struct pending_block *old_blocks;
  703.      CORE_ADDR start, end;
  704. {
  705.   register struct pending *next, *next1;
  706.   register struct block *block;
  707.   register struct pending_block *pblock;
  708.   struct pending_block *opblock;
  709.   register int i;
  710.  
  711.   /* Count the length of the list of symbols.  */
  712.  
  713.   for (next = *listhead, i = 0; next; i += next->nsyms, next = next->next);
  714.  
  715.   block = (struct block *) obstack_alloc (symbol_obstack,
  716.                       sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
  717.  
  718.   /* Copy the symbols into the block.  */
  719.  
  720.   BLOCK_NSYMS (block) = i;
  721.   for (next = *listhead; next; next = next->next)
  722.     {
  723.       register int j;
  724.       for (j = next->nsyms - 1; j >= 0; j--)
  725.     BLOCK_SYM (block, --i) = next->symbol[j];
  726.     }
  727.  
  728.   BLOCK_START (block) = start;
  729.   BLOCK_END (block) = end;
  730.   BLOCK_SUPERBLOCK (block) = 0;    /* Filled in when containing block is made */
  731.  
  732.   /* Put the block in as the value of the symbol that names it.  */
  733.  
  734.   if (symbol)
  735.     {
  736.       SYMBOL_BLOCK_VALUE (symbol) = block;
  737.       BLOCK_FUNCTION (block) = symbol;
  738.     }
  739.   else
  740.     BLOCK_FUNCTION (block) = 0;
  741.  
  742.   /* Now "free" the links of the list, and empty the list.  */
  743.  
  744.   for (next = *listhead; next; next = next1)
  745.     {
  746.       next1 = next->next;
  747.       next->next = free_pendings;
  748.       free_pendings = next;
  749.     }
  750.   *listhead = 0;
  751.  
  752.   /* Install this block as the superblock
  753.      of all blocks made since the start of this scope
  754.      that don't have superblocks yet.  */
  755.  
  756.   opblock = 0;
  757.   for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
  758.     {
  759.       if (BLOCK_SUPERBLOCK (pblock->block) == 0)
  760.     BLOCK_SUPERBLOCK (pblock->block) = block;
  761.       opblock = pblock;
  762.     }
  763.  
  764.   /* Record this block on the list of all blocks in the file.
  765.      Put it after opblock, or at the beginning if opblock is 0.
  766.      This puts the block in the list after all its subblocks.  */
  767.  
  768.   /* Allocate in the symbol_obstack to save time.
  769.      It wastes a little space.  */
  770.   pblock = (struct pending_block *) obstack_alloc (symbol_obstack,
  771.                            sizeof (struct pending_block));
  772.   pblock->block = block;
  773.   if (opblock)
  774.     {
  775.       pblock->next = opblock->next;
  776.       opblock->next = pblock;
  777.     }
  778.   else
  779.     {
  780.       pblock->next = pending_blocks;
  781.       pending_blocks = pblock;
  782.     }
  783. }
  784.  
  785. static struct blockvector *
  786. make_blockvector ()
  787. {
  788.   register struct pending_block *next, *next1;
  789.   register struct blockvector *blockvector;
  790.   register int i;
  791.  
  792.   /* Count the length of the list of blocks.  */
  793.  
  794.   for (next = pending_blocks, i = 0; next; next = next->next, i++);
  795.  
  796.   blockvector = (struct blockvector *) obstack_alloc (symbol_obstack, sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
  797.  
  798.   /* Copy the blocks into the blockvector.
  799.      This is done in reverse order, which happens to put
  800.      the blocks into the proper order (ascending starting address).
  801.      finish_block has hair to insert each block into the list
  802.      after its subblocks in order to make sure this is true.  */
  803.  
  804.   BLOCKVECTOR_NBLOCKS (blockvector) = i;
  805.   for (next = pending_blocks; next; next = next->next)
  806.     BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
  807.  
  808. #if 0 /* Now we make the links in the obstack, so don't free them.  */
  809.   /* Now free the links of the list, and empty the list.  */
  810.  
  811.   for (next = pending_blocks; next; next = next1)
  812.     {
  813.       next1 = next->next;
  814.       free (next);
  815.     }
  816. #endif
  817.   pending_blocks = 0;
  818.  
  819.   return blockvector;
  820. }
  821.  
  822. /* Manage the vector of line numbers.  */
  823.  
  824. static
  825. record_line (line, pc)
  826.      int line;
  827.      CORE_ADDR pc;
  828. {  
  829.   struct linetable_entry *e;
  830.   /* Ignore the dummy line number in libg.o */
  831.  
  832.   if (line == 0xffff)
  833.     return;
  834.  
  835.   /* Make sure line vector is big enough.  */
  836.  
  837.   if (line_vector_index + 1 >= line_vector_length)
  838.     {
  839.       line_vector_length *= 2;
  840.       line_vector = (struct linetable *)
  841.     xrealloc (line_vector,
  842.           (sizeof (struct linetable)
  843.            + line_vector_length * sizeof (struct linetable_entry)));
  844.       current_subfile->line_vector = line_vector;
  845.     }
  846.  
  847.   e = line_vector->item + line_vector_index++;
  848.   e->line = line; e->pc = pc;
  849. }
  850.  
  851. /* Start a new symtab for a new source file.
  852.    This is called when a dbx symbol of type N_SO is seen;
  853.    it indicates the start of data for one original source file.  */
  854.  
  855. static void
  856. start_symtab (name, start_addr)
  857.      char *name;
  858.      CORE_ADDR start_addr;
  859. {
  860.   register struct symtab *s;
  861.  
  862.   last_source_file = name;
  863.   last_source_start_addr = start_addr;
  864.   file_symbols = 0;
  865.   global_symbols = 0;
  866.   within_function = 0;
  867.  
  868.   /* Context stack is initially empty, with room for 10 levels.  */
  869.   context_stack
  870.     = (struct context_stack *) xxmalloc (10 * sizeof (struct context_stack));
  871.   context_stack_size = 10;
  872.   context_stack_depth = 0;
  873.  
  874.   new_object_header_files ();
  875.  
  876.   type_vector_length = 160;
  877.   type_vector = (struct typevector *) xxmalloc (sizeof (struct typevector) + type_vector_length * sizeof (struct type *));
  878.   bzero (type_vector->type, type_vector_length * sizeof (struct type *));
  879.  
  880.   /* Initialize the list of sub source files with one entry
  881.      for this file (the top-level source file).  */
  882.  
  883.   subfiles = 0;
  884.   current_subfile = 0;
  885.   start_subfile (name);
  886. }
  887.  
  888. /* Handle an N_SOL symbol, which indicates the start of
  889.    code that came from an included (or otherwise merged-in)
  890.    source file with a different name.  */
  891.  
  892. static void
  893. start_subfile (name)
  894.      char *name;
  895. {
  896.   register struct subfile *subfile;
  897.  
  898.   /* Save the current subfile's line vector data.  */
  899.  
  900.   if (current_subfile)
  901.     {
  902.       current_subfile->line_vector_index = line_vector_index;
  903.       current_subfile->line_vector_length = line_vector_length;
  904.       current_subfile->prev_line_number = prev_line_number;
  905.     }
  906.  
  907.   /* See if this subfile is already known as a subfile of the
  908.      current main source file.  */
  909.  
  910.   for (subfile = subfiles; subfile; subfile = subfile->next)
  911.     {
  912.       if (!strcmp (subfile->name, name))
  913.     {
  914.       line_vector = subfile->line_vector;
  915.       line_vector_index = subfile->line_vector_index;
  916.       line_vector_length = subfile->line_vector_length;
  917.       prev_line_number = subfile->prev_line_number;
  918.       current_subfile = subfile;
  919.       return;
  920.     }
  921.     }
  922.  
  923.   /* This subfile is not known.  Add an entry for it.  */
  924.  
  925.   line_vector_index = 0;
  926.   line_vector_length = 1000;
  927.   prev_line_number = -2;    /* Force first line number to be explicit */
  928.   line_vector = (struct linetable *)
  929.     xxmalloc (sizeof (struct linetable)
  930.           + line_vector_length * sizeof (struct linetable_entry));
  931.  
  932.   /* Make an entry for this subfile in the list of all subfiles
  933.      of the current main source file.  */
  934.  
  935.   subfile = (struct subfile *) xxmalloc (sizeof (struct subfile));
  936.   subfile->next = subfiles;
  937.   subfile->name = savestring (name, strlen (name));
  938.   subfile->line_vector = line_vector;
  939.   subfiles = subfile;
  940.   current_subfile = subfile;
  941. }
  942.  
  943. /* Finish the symbol definitions for one main source file,
  944.    close off all the lexical contexts for that file
  945.    (creating struct block's for them), then make the struct symtab
  946.    for that file and put it in the list of all such.
  947.  
  948.    END_ADDR is the address of the end of the file's text.  */
  949.  
  950. static void
  951. end_symtab (end_addr)
  952.      CORE_ADDR end_addr;
  953. {
  954.   register struct symtab *symtab;
  955.   register struct blockvector *blockvector;
  956.   register struct subfile *subfile;
  957.   register struct linetable *lv;
  958.   struct subfile *nextsub;
  959.  
  960.   /* Finish the lexical context of the last function in the file;
  961.      pop the context stack.  */
  962.  
  963.   if (context_stack_depth > 0)
  964.     {
  965.       register struct context_stack *cstk;
  966.       context_stack_depth--;
  967.       cstk = &context_stack[context_stack_depth];
  968.       /* Make a block for the local symbols within.  */
  969.       finish_block (cstk->name, &local_symbols, cstk->old_blocks,
  970.             cstk->start_addr, end_addr);
  971.     }
  972.  
  973.   /* Cleanup any undefined types that have been left hanging around
  974.      (this needs to be done before the finish_blocks so that
  975.      file_symbols is still good).  */
  976.   cleanup_undefined_types ();
  977.  
  978.   /* Finish defining all the blocks of this symtab.  */
  979.   finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
  980.   finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
  981.   blockvector = make_blockvector ();
  982.  
  983.   current_subfile->line_vector_index = line_vector_index;
  984.  
  985.   /* Now create the symtab objects proper, one for each subfile.  */
  986.   /* (The main file is one of them.)  */
  987.  
  988.   for (subfile = subfiles; subfile; subfile = nextsub)
  989.     {
  990.       symtab = (struct symtab *) xxmalloc (sizeof (struct symtab));
  991.       symtab->free_ptr = 0;
  992.  
  993.       /* Fill in its components.  */
  994.       symtab->blockvector = blockvector;
  995.       type_vector->length = type_vector_length;
  996.       symtab->typevector = type_vector;
  997.       symtab->free_code = free_linetable;
  998.       if (subfile->next == 0)
  999.     symtab->free_ptr = (char *) type_vector;
  1000.  
  1001.       symtab->filename = subfile->name;
  1002.       lv = subfile->line_vector;
  1003.       lv->nitems = subfile->line_vector_index;
  1004.       symtab->linetable = (struct linetable *)
  1005.     xrealloc (lv, (sizeof (struct linetable)
  1006.                + lv->nitems * sizeof (struct linetable_entry)));
  1007.       symtab->nlines = 0;
  1008.       symtab->line_charpos = 0;
  1009.  
  1010.       /* Link the new symtab into the list of such.  */
  1011.       symtab->next = symtab_list;
  1012.       symtab_list = symtab;
  1013.  
  1014.       nextsub = subfile->next;
  1015.       free (subfile);
  1016.     }
  1017.  
  1018.   type_vector = 0;
  1019.   type_vector_length = -1;
  1020.   line_vector = 0;
  1021.   line_vector_length = -1;
  1022.   last_source_file = 0;
  1023. }
  1024.  
  1025. #ifdef N_BINCL
  1026.  
  1027. /* Handle the N_BINCL and N_EINCL symbol types
  1028.    that act like N_SOL for switching source files
  1029.    (different subfiles, as we call them) within one object file,
  1030.    but using a stack rather than in an arbitrary order.  */
  1031.  
  1032. struct subfile_stack
  1033. {
  1034.   struct subfile_stack *next;
  1035.   char *name;
  1036.   int prev_index;
  1037. };
  1038.  
  1039. struct subfile_stack *subfile_stack;
  1040.  
  1041. static void
  1042. push_subfile ()
  1043. {
  1044.   register struct subfile_stack *tem
  1045.     = (struct subfile_stack *) xxmalloc (sizeof (struct subfile_stack));
  1046.  
  1047.   tem->next = subfile_stack;
  1048.   subfile_stack = tem;
  1049.   if (current_subfile == 0 || current_subfile->name == 0)
  1050.     abort ();
  1051.   tem->name = current_subfile->name;
  1052.   tem->prev_index = header_file_prev_index;
  1053. }
  1054.  
  1055. static char *
  1056. pop_subfile ()
  1057. {
  1058.   register char *name;
  1059.   register struct subfile_stack *link = subfile_stack;
  1060.  
  1061.   if (link == 0)
  1062.     abort ();
  1063.  
  1064.   name = link->name;
  1065.   subfile_stack = link->next;
  1066.   header_file_prev_index = link->prev_index;
  1067.   free (link);
  1068.  
  1069.   return name;
  1070. }
  1071. #endif /* Have N_BINCL */
  1072.  
  1073. /* Accumulate the misc functions in bunches of 127.
  1074.    At the end, copy them all into one newly allocated structure.  */
  1075.  
  1076. #define MISC_BUNCH_SIZE 127
  1077.  
  1078. struct misc_bunch
  1079. {
  1080.   struct misc_bunch *next;
  1081.   struct misc_function contents[MISC_BUNCH_SIZE];
  1082. };
  1083.  
  1084. /* Bunch currently being filled up.
  1085.    The next field points to chain of filled bunches.  */
  1086.  
  1087. static struct misc_bunch *misc_bunch;
  1088.  
  1089. /* Number of slots filled in current bunch.  */
  1090.  
  1091. static int misc_bunch_index;
  1092.  
  1093. /* Total number of misc functions recorded so far.  */
  1094.  
  1095. static int misc_count;
  1096.  
  1097. static void
  1098. init_misc_functions ()
  1099. {
  1100.   misc_count = 0;
  1101.   misc_bunch = 0;
  1102.   misc_bunch_index = MISC_BUNCH_SIZE;
  1103. }
  1104.  
  1105. static void
  1106. record_misc_function (name, address)
  1107.      char *name;
  1108.      CORE_ADDR address;
  1109. {
  1110.   register struct misc_bunch *new;
  1111.  
  1112. #ifdef atarist
  1113.   if (strcmp (name, "gcc_compiled.") == 0 ||
  1114.       strcmp (name, "gcc2_compiled.") == 0)
  1115.       return;
  1116. #endif
  1117.   
  1118.   if (misc_bunch_index == MISC_BUNCH_SIZE)
  1119.     {
  1120.       new = (struct misc_bunch *) xxmalloc (sizeof (struct misc_bunch));
  1121.       misc_bunch_index = 0;
  1122.       new->next = misc_bunch;
  1123.       misc_bunch = new;
  1124.     }
  1125.   misc_bunch->contents[misc_bunch_index].name = name;
  1126.   misc_bunch->contents[misc_bunch_index].address = address;
  1127.   misc_bunch_index++;
  1128.   misc_count++;
  1129. }
  1130.  
  1131. static int
  1132. compare_misc_functions (fn1, fn2)
  1133.      struct misc_function *fn1, *fn2;
  1134. {
  1135.   /* Return a signed result based on unsigned comparisons
  1136.      so that we sort into unsigned numeric order.  */
  1137.   if (fn1->address < fn2->address)
  1138.     return -1;
  1139.   if (fn1->address > fn2->address)
  1140.     return 1;
  1141.   return 0;
  1142. }
  1143.  
  1144. static void
  1145. discard_misc_bunches ()
  1146. {
  1147.   register struct misc_bunch *next;
  1148.  
  1149.   while (misc_bunch)
  1150.     {
  1151.       next = misc_bunch->next;
  1152.       free (misc_bunch);
  1153.       misc_bunch = next;
  1154.     }
  1155. }
  1156.  
  1157. static void
  1158. condense_misc_bunches ()
  1159. {
  1160.   register int i, j;
  1161.   register struct misc_bunch *bunch;
  1162. #ifdef NAMES_HAVE_UNDERSCORE
  1163.   int offset = 1;
  1164. #else
  1165.   int offset = 0;
  1166. #endif
  1167.  
  1168.   misc_function_vector
  1169.     = (struct misc_function *)
  1170.       xxmalloc (misc_count * sizeof (struct misc_function));
  1171.  
  1172.   j = 0;
  1173.   bunch = misc_bunch;
  1174.   while (bunch)
  1175.     {
  1176.       for (i = 0; i < misc_bunch_index; i++)
  1177.     {
  1178.       misc_function_vector[j] = bunch->contents[i];
  1179.       misc_function_vector[j].name
  1180.         = obconcat (misc_function_vector[j].name
  1181.             + (misc_function_vector[j].name[0] == '_' ? offset : 0),
  1182.             "", "");
  1183.       j++;
  1184.     }
  1185.       bunch = bunch->next;
  1186.       misc_bunch_index = MISC_BUNCH_SIZE;
  1187.     }
  1188.  
  1189.   misc_function_count = j;
  1190.  
  1191.   /* Sort the misc functions by address.  */
  1192.  
  1193.   qsort (misc_function_vector, j, sizeof (struct misc_function),
  1194.      compare_misc_functions);
  1195. }
  1196.  
  1197. /* Call sort_syms to sort alphabetically
  1198.    the symbols of each block of each symtab.  */
  1199.  
  1200. static int
  1201. compare_symbols (s1, s2)
  1202.      struct symbol **s1, **s2;
  1203. {
  1204.   register int namediff;
  1205.  
  1206.   /* Compare the initial characters.  */
  1207.   namediff = SYMBOL_NAME (*s1)[0] - SYMBOL_NAME (*s2)[0];
  1208.   if (namediff != 0) return namediff;
  1209.  
  1210.   /* If they match, compare the rest of the names.  */
  1211.   namediff = strcmp (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2));
  1212.   if (namediff != 0) return namediff;
  1213.  
  1214.   /* For symbols of the same name, registers should come first.  */
  1215.   return ((SYMBOL_CLASS (*s2) == LOC_REGISTER)
  1216.       - (SYMBOL_CLASS (*s1) == LOC_REGISTER));
  1217. }
  1218.  
  1219. static void sort_symtab_syms ();
  1220.  
  1221. static void
  1222. sort_syms ()
  1223. {
  1224.   register struct symtab *s;
  1225.  
  1226.   for (s = symtab_list; s; s = s->next)
  1227.     sort_symtab_syms (s);
  1228. }
  1229.  
  1230. static void
  1231. sort_symtab_syms (s)
  1232.      register struct symtab *s;
  1233. {
  1234.   register struct blockvector *bv = BLOCKVECTOR (s);
  1235.   int nbl = BLOCKVECTOR_NBLOCKS (bv);
  1236.   int i;
  1237.   register struct block *b;
  1238.  
  1239.   /* Note that in the following sort, we always make sure that
  1240.      register debug symbol declarations always come before regular
  1241.      debug symbol declarations (as might happen when parameters are
  1242.      then put into registers by the compiler).  We do this by a
  1243.      correct compare in compare_symbols, and by the reversal of the
  1244.      symbols if we don't sort.  This works as long as a register debug
  1245.      symbol always comes after a parameter debug symbol. */
  1246.  
  1247.   /* This is no longer necessary; lookup_block_symbol now always
  1248.      prefers some other declaration over a parameter declaration.  We
  1249.      still sort the thing (that is necessary), but we don't reverse it
  1250.      if we shouldn't sort it.  */
  1251.  
  1252.   for (i = 0; i < nbl; i++)
  1253.     {
  1254.       b = BLOCKVECTOR_BLOCK (bv, i);
  1255.       if (BLOCK_SHOULD_SORT (b))
  1256.     qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
  1257.            sizeof (struct symbol *), compare_symbols);
  1258.     }
  1259. }
  1260.  
  1261.  
  1262. /* This is the symbol-file command.  Read the file, analyze its symbols,
  1263.    and add a struct symtab to symtab_list.  */
  1264.  
  1265. void
  1266. symbol_file_command (name)
  1267.      char *name;
  1268. {
  1269.   register int desc;
  1270.   DECLARE_FILE_HEADERS;
  1271.   struct nlist *nlist;
  1272.   char *stringtab;
  1273.   long buffer;
  1274.   register int val;
  1275.   extern void close ();
  1276.   struct cleanup *old_chain;
  1277.   struct symtab *symseg;
  1278.   struct stat statbuf;
  1279.  
  1280.   dont_repeat ();
  1281.  
  1282.   if (name == 0)
  1283.     {
  1284.       if (symtab_list && !query ("Discard symbol table? ", 0))
  1285.     error ("Not confirmed.");
  1286.       if(symfile)
  1287.       free(symfile);
  1288.       symfile = 0;
  1289.       free_all_symtabs ();
  1290.       return;
  1291.     }
  1292.  
  1293.   if (symtab_list && !query ("Load new symbol table from \"%s\"? ", name))
  1294.     error ("Not confirmed.");
  1295.  
  1296.   {
  1297.     char *absolute_name;
  1298.     desc = openp (getenv ("PATH"), 1, name, O_RDONLY, 0, &absolute_name);
  1299.     if (desc < 0)
  1300.       perror_with_name (name);
  1301.     else
  1302.       name = absolute_name;
  1303.   }
  1304.  
  1305.   old_chain = make_cleanup (close, desc);
  1306.   make_cleanup (free_current_contents, &name);
  1307.  
  1308.   READ_FILE_HEADERS (desc, name);
  1309.  
  1310.   if (NUMBER_OF_SYMBOLS == 0)
  1311.     {
  1312.       if (symfile)
  1313.     free (symfile);
  1314.       symfile = 0;
  1315.       free_all_symtabs ();
  1316.      printf_filtered ("%s has no symbol-table; symbols discarded.\n", name);
  1317.       fflush (stdout);
  1318.       do_cleanups (old_chain);
  1319.       return;
  1320.     }
  1321.  
  1322.  printf_filtered ("Reading symbol data from %s...", name);
  1323.   fflush (stdout);
  1324.  
  1325.   /* Now read the string table, all at once.  */
  1326.   val = lseek (desc, STRING_TABLE_OFFSET, 0);
  1327.   if (val < 0)
  1328.     perror_with_name (name);
  1329.   if (stat (name, &statbuf) == -1)
  1330.     perror_with_name (name);
  1331.   READ_STRING_TABLE_SIZE (buffer);
  1332.   if (buffer >= 0 && buffer < statbuf.st_size)
  1333.     stringtab = (char *) alloca (buffer);
  1334.   else
  1335.     stringtab = NULL;
  1336.   if (stringtab == NULL)
  1337.     error ("ridiculous string table size: %d bytes", name, buffer);
  1338.  
  1339.   /* Usually READ_STRING_TABLE_SIZE will have shifted the file pointer.
  1340.      Occaisionally, it won't.  */
  1341.   val = lseek (desc, STRING_TABLE_OFFSET, 0);
  1342.   if (val < 0)
  1343.     perror_with_name (name);
  1344.   val = myread (desc, stringtab, buffer);
  1345.   if (val < 0)
  1346.     perror_with_name (name);
  1347.  
  1348.   /* Throw away the old symbol table.  */
  1349.  
  1350.   if (symfile)
  1351.     free (symfile);
  1352.   symfile = 0;
  1353.   free_all_symtabs ();
  1354.  
  1355.   /* Empty the hash table of global syms looking for values.  */
  1356.   bzero (global_sym_chain, sizeof global_sym_chain);
  1357.  
  1358.   /* Position to read the symbol table.  Do not read it all at once. */
  1359.   val = lseek (desc, SYMBOL_TABLE_OFFSET, 0);
  1360.   if (val < 0)
  1361.     perror_with_name (name);
  1362.  
  1363.   /* Don't put these on the cleanup chain; they need to stick around
  1364.      until the next call to symbol_file_command.  *Then* we'll free
  1365.      them. */
  1366.   free_header_files ();
  1367.   init_header_files ();
  1368.  
  1369.   init_misc_functions ();
  1370.   make_cleanup (discard_misc_bunches, 0);
  1371.  
  1372.   free_pendings = 0;
  1373.   pending_blocks = 0;
  1374.   file_symbols = 0;
  1375.   global_symbols = 0;
  1376.   make_cleanup (really_free_pendings, 0);
  1377.  
  1378.   /* Now that the symbol table data of the executable file are all in core,
  1379.      process them and define symbols accordingly.  Closes desc.  */
  1380.  
  1381.   read_dbx_symtab (desc, stringtab, NUMBER_OF_SYMBOLS);
  1382.   close (desc);
  1383.  
  1384.   /* Sort symbols alphabetically within each block.  */
  1385.  
  1386.   sort_syms ();
  1387.  
  1388.   /* Go over the misc functions and install them in vector.  */
  1389.  
  1390.   condense_misc_bunches ();
  1391.  
  1392.   /* Don't allow char * to have a typename (else would get caddr_t.)  */
  1393.  
  1394.   TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
  1395.  
  1396.   /* Make a default for file to list.  */
  1397.  
  1398.   select_source_symtab (symtab_list);
  1399.  
  1400.   symfile = savestring (name, strlen (name));
  1401.  
  1402.   do_cleanups (old_chain);
  1403.  
  1404.  printf_filtered ("done.\n");
  1405.   fflush (stdout);
  1406. }
  1407.  
  1408. /* Return name of file symbols were loaded from, or 0 if none..  */
  1409.  
  1410. char *
  1411. get_sym_file ()
  1412. {
  1413.   return symfile;
  1414. }
  1415.  
  1416. /* Buffer for reading the symbol table entries.  */
  1417. static struct nlist symbuf[2048];
  1418. static int symbuf_idx;
  1419. static int symbuf_end;
  1420.  
  1421. /* I/O descriptor for reading the symbol table.  */
  1422. static int symtab_input_desc;
  1423.  
  1424. /* The address of the string table
  1425.    of the object file we are reading (as copied into core).  */
  1426. static char *stringtab_global;
  1427.  
  1428. /* Refill the symbol table input buffer
  1429.    and set the variables that control fetching entries from it.
  1430.    Reports an error if no data available.
  1431.    This function can read past the end of the symbol table
  1432.    (into the string table) but this does no harm.  */
  1433.  
  1434. static int
  1435. fill_symbuf ()
  1436. {
  1437.   int nbytes = myread (symtab_input_desc, symbuf, sizeof (symbuf));
  1438.   if (nbytes <= 0)
  1439.     error ("error or end of file reading symbol table");
  1440.   symbuf_end = nbytes / sizeof (struct nlist);
  1441.   symbuf_idx = 0;
  1442.   return 1;
  1443. }
  1444.  
  1445. /* dbx allows the text of a symbol name to be continued into the
  1446.    next symbol name!  When such a continuation is encountered
  1447.    (a \ at the end of the text of a name)
  1448.    call this function to get the continuation.  */
  1449.  
  1450. static char *
  1451. next_symbol_text ()
  1452. {
  1453.   if (symbuf_idx == symbuf_end)
  1454.     fill_symbuf ();
  1455.   symnum++;
  1456.   return symbuf[symbuf_idx++].n_un.n_strx + stringtab_global;
  1457. }
  1458.  
  1459. /* Given pointers to a a.out symbol table in core containing  dbx style data,
  1460.    analyze them and create struct symtab's describing the symbols.
  1461.    NLISTLEN is the number of symbols in the symbol table.
  1462.    We read them one at a time using stdio.
  1463.    All symbol names are given as offsets relative to STRINGTAB.  */
  1464.  
  1465. static void
  1466. read_dbx_symtab (desc, stringtab, nlistlen)
  1467.      int desc;
  1468.      register char *stringtab;
  1469.      register int nlistlen;
  1470. {
  1471.   register char *namestring;
  1472.   register struct symbol *sym, *prev;
  1473.   int hash;
  1474.   int num_object_files = 0;
  1475.   struct cleanup *old_chain;
  1476.  
  1477. #ifdef N_BINCL
  1478.   subfile_stack = 0;
  1479. #endif
  1480.  
  1481.   old_chain = make_cleanup (free_all_symtabs, 0);
  1482.   stringtab_global = stringtab;
  1483.   last_source_file = 0;
  1484.  
  1485. #ifdef END_OF_TEXT_DEFAULT
  1486.   end_of_text_addr = END_OF_TEXT_DEFAULT;
  1487. #endif
  1488.  
  1489.   symtab_input_desc = desc;
  1490.   symbuf_end = symbuf_idx = 0;
  1491.  
  1492.   for (symnum = 0; symnum < nlistlen; symnum++)
  1493.     {
  1494.       struct nlist *bufp;
  1495.       int type;
  1496.  
  1497.       QUIT;    /* allow this to be interruptable */
  1498.       if (symbuf_idx == symbuf_end)
  1499.     fill_symbuf ();
  1500.       bufp = &symbuf[symbuf_idx++];
  1501.       type = bufp->n_type;
  1502.       namestring = bufp->n_un.n_strx ? bufp->n_un.n_strx + stringtab : "";
  1503.  
  1504.       if (type & N_STAB)
  1505.     process_one_symbol (type, bufp->n_desc,
  1506.                 bufp->n_value, namestring);
  1507.       /* A static text symbol whose name ends in ".o"
  1508.      can only mean the start of another object file.
  1509.      So end the symtab of the source file we have been processing.
  1510.      This is how we avoid counting the libraries as part
  1511.      or the last source file.
  1512.      Also this way we find end of first object file (crt0).  */
  1513.       else if ((type == N_TEXT
  1514. #ifdef N_NBTEXT
  1515.         || type == N_NBTEXT
  1516. #endif
  1517.         )
  1518.            && !strcmp (namestring + strlen (namestring) - 2, ".o"))
  1519.     {
  1520.       if (num_object_files++ == 1)
  1521.         first_object_file_end = bufp->n_value;
  1522.       if (last_source_file)
  1523.         end_symtab (bufp->n_value);
  1524.     }
  1525.       else if (type & N_EXT || type == N_TEXT
  1526. #ifdef N_NBTEXT
  1527.            || type == N_NBTEXT
  1528. #endif
  1529.            )
  1530.     {
  1531.       int used_up = 0;
  1532.  
  1533.       /* Record the location of _etext.  */
  1534.       if (type == (N_TEXT | N_EXT)
  1535.           && !strcmp (namestring, "_etext"))
  1536.         end_of_text_addr = bufp->n_value;
  1537.  
  1538.       /* Global symbol: see if we came across a dbx definition
  1539.          for a corresponding symbol.  If so, store the value.
  1540.          Remove syms from the chain when their values are stored,
  1541.          but search the whole chain, as there may be several syms
  1542.          from different files with the same name.  */
  1543.       if (type & N_EXT)
  1544.         {
  1545.           prev = 0;
  1546. #ifdef NAMES_HAVE_UNDERSCORE
  1547.           hash = hashname (namestring + 1);
  1548. #else /* not NAMES_HAVE_UNDERSCORE */
  1549.           hash = hashname (namestring);
  1550. #endif /* not NAMES_HAVE_UNDERSCORE */
  1551.           for (sym = global_sym_chain[hash];
  1552.            sym;)
  1553.         {
  1554.           if (
  1555. #ifdef NAMES_HAVE_UNDERSCORE
  1556.               *namestring == '_'
  1557.               && namestring[1] == SYMBOL_NAME (sym)[0]
  1558.               &&
  1559.               !strcmp (namestring + 2, SYMBOL_NAME (sym) + 1)
  1560. #else /* NAMES_HAVE_UNDERSCORE */
  1561.               namestring[0] == SYMBOL_NAME (sym)[0]
  1562.               &&
  1563.               !strcmp (namestring + 1, SYMBOL_NAME (sym) + 1)
  1564. #endif /* NAMES_HAVE_UNDERSCORE */
  1565.               )
  1566.             {
  1567.               if (prev)
  1568.             SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
  1569.               else
  1570.             global_sym_chain[hash]
  1571.               = (struct symbol *) SYMBOL_VALUE (sym);
  1572.               SYMBOL_VALUE (sym) = bufp->n_value;
  1573.               if (prev)
  1574.             sym = (struct symbol *) SYMBOL_VALUE (prev);
  1575.               else
  1576.             sym = global_sym_chain[hash];
  1577.  
  1578.               used_up = 1;
  1579.             }
  1580.           else
  1581.             {
  1582.               prev = sym;
  1583.               sym = (struct symbol *) SYMBOL_VALUE (sym);
  1584.             }
  1585.         }
  1586.         }
  1587.  
  1588.       /* Defined global or text symbol: record as a misc function
  1589.          if it didn't give its address to a debugger symbol above.  */
  1590.       if (type <= (N_TYPE | N_EXT)
  1591.           && type != N_EXT
  1592.           && ! used_up)
  1593.         record_misc_function (namestring, bufp->n_value);
  1594.     }
  1595.     }
  1596.  
  1597.   if (last_source_file)
  1598.     end_symtab (end_of_text_addr);
  1599.  
  1600.   discard_cleanups (old_chain);
  1601. }
  1602.  
  1603. static int
  1604. hashname (name)
  1605.      char *name;
  1606. {
  1607.   register char *p = name;
  1608.   register int total = p[0];
  1609.   register int c;
  1610.  
  1611.   c = p[1];
  1612.   total += c << 2;
  1613.   if (c)
  1614.     {
  1615.       c = p[2];
  1616.       total += c << 4;
  1617.       if (c)
  1618.     total += p[3] << 6;
  1619.     }
  1620.  
  1621.   /* Ensure result is positive.  */
  1622.   if (total < 0) total += (1000 << 6);
  1623.   return total % HASHSIZE;
  1624. }
  1625.  
  1626. static void
  1627. process_one_symbol (type, desc, value, name)
  1628.      int type, desc;
  1629.      CORE_ADDR value;
  1630.      char *name;
  1631. {
  1632.   register struct context_stack *new;
  1633.   char *colon_pos, *index();
  1634.  
  1635.   /* Something is wrong if we see real data before
  1636.      seeing a source file name.  */
  1637.  
  1638.   if (last_source_file == 0 && type != N_SO)
  1639.     {
  1640. #ifdef N_NSYMS
  1641.       /* This code is used on Ultrix; ignore this sym.  */
  1642.       if (type == N_NSYMS)
  1643.     return;
  1644. #endif
  1645.  
  1646.       if (type == N_ENTRY)
  1647.     /* This code appears in libraries on Gould machines.  */
  1648.     return;
  1649.       error ("Invalid symbol data: does not start by identifying a source file.");
  1650.     }
  1651.  
  1652.   switch (type)
  1653.     {
  1654.     case N_FUN:
  1655.     case N_FNAME:
  1656.       /* Either of these types of symbols indicates the start of
  1657.      a new function.  We must process its "name" normally for dbx,
  1658.      but also record the start of a new lexical context, and possibly
  1659.      also the end of the lexical context for the previous function.  */
  1660.       /* This is not always true.  This type of symbol may indicate a
  1661.          text segment variable.  */
  1662.  
  1663.       colon_pos = index (name, ':');
  1664.       if (!colon_pos++
  1665.       || (*colon_pos != 'f' && *colon_pos != 'F'))
  1666.     {
  1667.       define_symbol (value, name, desc);
  1668.       break;
  1669.     }
  1670.  
  1671.       within_function = 1;
  1672.       if (context_stack_depth > 0)
  1673.     {
  1674.       new = &context_stack[--context_stack_depth];
  1675.       /* Make a block for the local symbols within.  */
  1676.       finish_block (new->name, &local_symbols, new->old_blocks,
  1677.             new->start_addr, value);
  1678.     }
  1679.       /* Stack must be empty now.  */
  1680.       if (context_stack_depth != 0)
  1681.     error ("Invalid symbol data: unmatched N_LBRAC before symtab pos %d.",
  1682.            symnum);
  1683.  
  1684.       new = &context_stack[context_stack_depth++];
  1685.       new->old_blocks = pending_blocks;
  1686.       new->start_addr = value;
  1687.       new->name = define_symbol (value, name, desc);
  1688.       local_symbols = 0;
  1689.       break;
  1690.  
  1691.     case N_LBRAC:
  1692.       /* This "symbol" just indicates the start of an inner lexical
  1693.      context within a function.  */
  1694.  
  1695.       if (context_stack_depth == context_stack_size)
  1696.     {
  1697.       context_stack_size *= 2;
  1698.       context_stack
  1699.         = (struct context_stack *) xrealloc (context_stack,
  1700.                          context_stack_size
  1701.                          * sizeof (struct context_stack));
  1702.     }
  1703.  
  1704.       new = &context_stack[context_stack_depth++];
  1705.       new->depth = desc;
  1706.       new->locals = local_symbols;
  1707.       new->old_blocks = pending_blocks;
  1708.       new->start_addr = value;
  1709.       new->name = 0;
  1710.       local_symbols = 0;
  1711.       break;
  1712.  
  1713.     case N_RBRAC:
  1714.       /* This "symbol" just indicates the end of an inner lexical
  1715.      context that was started with N_RBRAC.  */
  1716.       new = &context_stack[--context_stack_depth];
  1717.       if (desc != new->depth)
  1718.     error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
  1719.       local_symbols = new->locals;
  1720.  
  1721.       /* If this is not the outermost LBRAC...RBRAC pair in the
  1722.      function, its local symbols preceded it, and are the ones
  1723.      just recovered from the context stack.  Defined the block for them.
  1724.  
  1725.      If this is the outermost LBRAC...RBRAC pair, there is no
  1726.      need to do anything; leave the symbols that preceded it
  1727.      to be attached to the function's own block.  */
  1728.       if (local_symbols && context_stack_depth > 1)
  1729.     {
  1730.       /* Muzzle a compiler bug that makes end < start.  */
  1731.       if (new->start_addr > value)
  1732.         new->start_addr = value;
  1733.       /* Make a block for the local symbols within.  */
  1734.       finish_block (0, &local_symbols, new->old_blocks,
  1735.             new->start_addr + last_source_start_addr,
  1736.             value + last_source_start_addr);
  1737.     }
  1738.       else
  1739.     {
  1740.       within_function = 0;
  1741.     }
  1742.       break;
  1743.  
  1744.     case N_FN:
  1745.       /* This kind of symbol supposedly indicates the start
  1746.      of an object file.  In fact this type does not appear.  */
  1747.       break;
  1748.  
  1749.     case N_SO:
  1750.       /* This type of symbol indicates the start of data
  1751.      for one source file.
  1752.      Finish the symbol table of the previous source file
  1753.      (if any) and start accumulating a new symbol table.  */
  1754.       if (last_source_file)
  1755.     end_symtab (value);
  1756.       start_symtab (name, value);
  1757.       break;
  1758.  
  1759.     case N_SOL:
  1760.       /* This type of symbol indicates the start of data for
  1761.      a sub-source-file, one whose contents were copied or
  1762.      included in the compilation of the main source file
  1763.      (whose name was given in the N_SO symbol.)  */
  1764.       start_subfile (name);
  1765.       break;
  1766.  
  1767. #ifdef N_BINCL
  1768.     case N_BINCL:
  1769.       push_subfile ();
  1770.       add_new_header_file (name, value);
  1771.       start_subfile (name);
  1772.       break;
  1773.  
  1774.     case N_EINCL:
  1775.       start_subfile (pop_subfile ());
  1776.       break;
  1777.  
  1778.     case N_EXCL:
  1779.       add_old_header_file (name, value);
  1780.       break;
  1781. #endif /* have N_BINCL */
  1782.  
  1783.     case N_SLINE:
  1784.       /* This type of "symbol" really just records
  1785.      one line-number -- core-address correspondence.
  1786.      Enter it in the line list for this symbol table.  */
  1787.       record_line (desc, value);
  1788.       break;
  1789.  
  1790.     case N_BCOMM:
  1791.     case N_ECOMM:
  1792.     case N_ECOML:
  1793.     case N_LENG:
  1794.       break;
  1795.  
  1796.     default:
  1797.       if (name)
  1798.     define_symbol (value, name, desc);
  1799.     }
  1800. }
  1801.  
  1802. static void read_type_number ();
  1803.  
  1804. static struct symbol *
  1805. define_symbol (value, string, desc)
  1806.      int value;
  1807.      char *string;
  1808.      int desc;
  1809. {
  1810.   register struct symbol *sym
  1811.     = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
  1812.   char *p = (char *) index (string, ':');
  1813.   int deftype;
  1814.   register int i;
  1815.  
  1816.   /* Ignore syms with empty names.  */
  1817.   if (string[0] == 0)
  1818.     return 0;
  1819.  
  1820.   /* Ignore old-style symbols from cc -go  */
  1821.   if (p == 0)
  1822.     return 0;
  1823.  
  1824.   SYMBOL_NAME (sym)
  1825.     = (char *) obstack_alloc (symbol_obstack, ((p - string) + 1));
  1826.   /* Open-coded bcopy--saves function call time.  */
  1827.   {
  1828.     register char *p1 = string;
  1829.     register char *p2 = SYMBOL_NAME (sym);
  1830.     while (p1 != p)
  1831.       *p2++ = *p1++;
  1832.     *p2++ = '\0';
  1833.   }
  1834.   p++;
  1835.   /* Determine the type of name being defined.  */
  1836.   if ((*p >= '0' && *p <= '9') || *p == '(')
  1837.     deftype = 'l';
  1838.   else
  1839.     deftype = *p++;
  1840.  
  1841.   /* c is a special case, not followed by a type-number.
  1842.      SYMBOL:c=iVALUE for an integer constant symbol.
  1843.      SYMBOL:c=rVALUE for a floating constant symbol.
  1844.      SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
  1845.         e.g. "b:c=e6,0" for "const b = blob1"
  1846.     (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
  1847.   if (deftype == 'c')
  1848.     {
  1849.       if (*p++ != '=')
  1850.     error ("Invalid symbol data at symtab pos %d.", symnum);
  1851.       switch (*p++)
  1852.     {
  1853.     case 'r':
  1854.       {
  1855.         extern double atof();
  1856.         double d = atof (p);
  1857.         char *value;
  1858.  
  1859.         SYMBOL_TYPE (sym) = builtin_type_double;
  1860.         value = (char *) obstack_alloc (symbol_obstack, sizeof (double));
  1861.         bcopy (&d, value, sizeof (double));
  1862.         SYMBOL_VALUE_BYTES (sym) = value;
  1863.         SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
  1864.       }
  1865.       break;
  1866.     case 'i':
  1867.       {
  1868.         SYMBOL_TYPE (sym) = builtin_type_int;
  1869.         SYMBOL_VALUE (sym) = atoi (p);
  1870.         SYMBOL_CLASS (sym) = LOC_CONST;
  1871.       }
  1872.       break;
  1873.     case 'e':
  1874.       /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
  1875.          e.g. "b:c=e6,0" for "const b = blob1"
  1876.          (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
  1877.       {
  1878.         int typenums[2];
  1879.         
  1880.         read_type_number (&p, typenums);
  1881.         if (*p++ != ',')
  1882.           error ("Invalid symbol data: no comma in enum const symbol");
  1883.         
  1884.         SYMBOL_TYPE (sym) = *dbx_lookup_type (typenums);
  1885.         SYMBOL_VALUE (sym) = atoi (p);
  1886.         SYMBOL_CLASS (sym) = LOC_CONST;
  1887.       }
  1888.       break;
  1889.     default:
  1890.       error ("Invalid symbol data at symtab pos %d.", symnum);
  1891.     }
  1892.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1893.       add_symbol_to_list (sym, &file_symbols);
  1894.       return sym;
  1895.     }
  1896.  
  1897.   /* Now usually comes a number that says which data type,
  1898.      and possibly more stuff to define the type
  1899.      (all of which is handled by read_type)  */
  1900.  
  1901.   if (deftype == 'T' && *p == 't')
  1902.     {
  1903.       deftype = 't';
  1904.       p++;
  1905.     }
  1906.  
  1907.   if (deftype == 'p' && *p == 'F')
  1908.     /* pF is a two-letter code that means a function parameter in Fortran.
  1909.        The type-number specifies the type of the return value.
  1910.        Translate it into a pointer-to-function type.  */
  1911.     {
  1912.       p++;
  1913.       SYMBOL_TYPE (sym)
  1914.     = lookup_pointer_type (lookup_function_type (read_type (&p)));
  1915.     }
  1916.   else
  1917.     {
  1918.       struct type *type = read_type (&p);
  1919.  
  1920.       if ((deftype == 'F' || deftype == 'f')
  1921.       && TYPE_CODE (type) != TYPE_CODE_FUNC)
  1922.     SYMBOL_TYPE (sym) = lookup_function_type (type);
  1923.       else
  1924.     SYMBOL_TYPE (sym) = type;
  1925.     }
  1926.  
  1927.   switch (deftype)
  1928.     {
  1929.     case 'f':
  1930.       SYMBOL_CLASS (sym) = LOC_BLOCK;
  1931.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1932.       add_symbol_to_list (sym, &file_symbols);
  1933.       break;
  1934.  
  1935.     case 'F':
  1936.       SYMBOL_CLASS (sym) = LOC_BLOCK;
  1937.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1938.       add_symbol_to_list (sym, &global_symbols);
  1939.       break;
  1940.  
  1941.     case 'G':
  1942.       /* For a class G (global) symbol, it appears that the
  1943.      value is not correct.  It is necessary to search for the
  1944.      corresponding linker definition to find the value.
  1945.      These definitions appear at the end of the namelist.  */
  1946.       i = hashname (SYMBOL_NAME (sym));
  1947.       SYMBOL_VALUE (sym) = (int) global_sym_chain[i];
  1948.       global_sym_chain[i] = sym;
  1949.       SYMBOL_CLASS (sym) = LOC_STATIC;
  1950.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1951.       add_symbol_to_list (sym, &global_symbols);
  1952.       break;
  1953.  
  1954.       /* This case is faked by a conditional above,
  1955.      when there is no code letter in the dbx data.
  1956.      Dbx data never actually contains 'l'.  */
  1957.     case 'l':
  1958.       SYMBOL_CLASS (sym) = LOC_LOCAL;
  1959.       SYMBOL_VALUE (sym) = value;
  1960.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1961.       add_symbol_to_list (sym, &local_symbols);
  1962.       break;
  1963.  
  1964.     case 'p':
  1965.       SYMBOL_CLASS (sym) = LOC_ARG;
  1966.       SYMBOL_VALUE (sym) = value;
  1967.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1968.       add_symbol_to_list (sym, &local_symbols);
  1969.       /* DESC == 0 implies compiled with GCC.
  1970.      In this case, if it says `short', believe it.  */
  1971. #ifndef atarist /* always gcc compiled */
  1972.       if (desc == 0) 
  1973. #endif
  1974.     break;
  1975.       /* If PCC says a parameter is a short or a char,
  1976.      it is really an int.  */
  1977.       if (SYMBOL_TYPE (sym) == builtin_type_char
  1978.       || SYMBOL_TYPE (sym) == builtin_type_short)
  1979.     SYMBOL_TYPE (sym) = builtin_type_int;
  1980.       else if (SYMBOL_TYPE (sym) == builtin_type_unsigned_char
  1981.            || SYMBOL_TYPE (sym) == builtin_type_unsigned_short)
  1982.     SYMBOL_TYPE (sym) = builtin_type_unsigned_int;
  1983.       break;
  1984.  
  1985.     case 'r':
  1986.       SYMBOL_CLASS (sym) = LOC_REGISTER;
  1987.       SYMBOL_VALUE (sym) = value;
  1988.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1989.       add_symbol_to_list (sym, &local_symbols);
  1990.       break;
  1991.  
  1992.     case 'S':
  1993.       /* Static symbol at top level of file */
  1994.       SYMBOL_CLASS (sym) = LOC_STATIC;
  1995.       SYMBOL_VALUE (sym) = value;
  1996.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  1997.       add_symbol_to_list (sym, &file_symbols);
  1998.       break;
  1999.  
  2000.     case 't':
  2001.       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
  2002.       SYMBOL_VALUE (sym) = value;
  2003.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  2004.       if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
  2005.       && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
  2006.     TYPE_NAME (SYMBOL_TYPE (sym)) =
  2007.       obsavestring (SYMBOL_NAME (sym),
  2008.             strlen (SYMBOL_NAME (sym)));
  2009.       add_symbol_to_list (sym, &file_symbols);
  2010.       break;
  2011.  
  2012.     case 'T':
  2013.       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
  2014.       SYMBOL_VALUE (sym) = value;
  2015.       SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
  2016.       if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
  2017.       && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
  2018.     TYPE_NAME (SYMBOL_TYPE (sym))
  2019.       = obconcat ("",
  2020.               (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM
  2021.                ? "enum "
  2022.                : (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
  2023.               ? "struct " : "union ")),
  2024.               SYMBOL_NAME (sym));
  2025.       add_symbol_to_list (sym, &file_symbols);
  2026.       break;
  2027.  
  2028.     case 'V':
  2029.     case 'v':
  2030.       /* Static symbol of local scope */
  2031.       SYMBOL_CLASS (sym) = LOC_STATIC;
  2032.       SYMBOL_VALUE (sym) = value;
  2033.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  2034.       add_symbol_to_list (sym, &local_symbols);
  2035.       break;
  2036.  
  2037.     case 'X':
  2038.       /* This is used by Sun FORTRAN for "function result value".
  2039.      Sun claims ("dbx and dbxtool interfaces", 2nd ed)
  2040.      that Pascal uses it too, but when I tried it Pascal used
  2041.      "x:3" (local symbol) instead.  */
  2042.       SYMBOL_CLASS (sym) = LOC_LOCAL;
  2043.       SYMBOL_VALUE (sym) = value;
  2044.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  2045.       add_symbol_to_list (sym, &local_symbols);
  2046.       break;
  2047.  
  2048.     default:
  2049.       error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
  2050.     }
  2051.   return sym;
  2052. }
  2053.  
  2054. /* What about types defined as forward references inside of a small lexical
  2055.    scope?  */
  2056. /* Add a type to the list of undefined types to be checked through
  2057.    once this file has been read in.  */
  2058. static void
  2059. add_undefined_type (type)
  2060.      struct type *type;
  2061. {
  2062.   if (undef_types_length == undef_types_allocated)
  2063.     {
  2064.       undef_types_allocated *= 2;
  2065.       undef_types = (struct type **)
  2066.     xrealloc (undef_types,
  2067.           undef_types_allocated * sizeof (struct type *));
  2068.     }
  2069.   undef_types[undef_types_length++] = type;
  2070. }
  2071.  
  2072. /* Add here something to go through each undefined type, see if it's
  2073.    still undefined, and do a full lookup if so.  */
  2074.  
  2075. /* 
  2076.    There is now a routine "check_stub_type" to check for undefined types
  2077.    at the time they are printed, and see if they can be resolved in some
  2078.    other file. However, this routine is still here so that references
  2079.    within a file are resolved to the most local definition.  I.e., if
  2080.    there are two different "struct foo"s in a program, then this routine
  2081.    will fix up all references in files that contain a definition.
  2082.  
  2083.    Probably, all undefined types should be resolved at the time they
  2084.    are output, and this routine should be removed.
  2085. */
  2086.  
  2087. static void
  2088. cleanup_undefined_types ()
  2089. {
  2090.   struct type **type, *ntype;
  2091.   struct symbol *sym;
  2092.  
  2093.   for (type = undef_types; type < undef_types + undef_types_length; type++)
  2094.     {
  2095.       struct type *ntype = 0;
  2096.       /* Reasonable test to see if it's been defined since.  */
  2097.       if (TYPE_NFIELDS (*type) == 0)
  2098.     {
  2099.       struct pending *ppt;
  2100.       int i;
  2101.       /* Name of the type, without "struct" or "union" */
  2102.       char *typename = TYPE_NAME (*type);
  2103.  
  2104.       if (!strncmp (typename, "struct ", 7))
  2105.         typename += 7;
  2106.       if (!strncmp (typename, "union ", 6))
  2107.         typename += 6;
  2108.  
  2109.       for (ppt = file_symbols; ppt; ppt = ppt->next)
  2110.         for (i = 0; i < ppt->nsyms; i++)
  2111.           {
  2112.         struct symbol *sym = ppt->symbol[i];
  2113.  
  2114.         if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
  2115.             && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
  2116.             && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
  2117.             TYPE_CODE (*type))
  2118.             && !strcmp (SYMBOL_NAME (sym), typename))
  2119.           bcopy (SYMBOL_TYPE (sym), *type, sizeof (struct type));
  2120.           }
  2121.     }
  2122.       else
  2123.     /* It has been defined; don't mark it as a stub.  */
  2124.     TYPE_FLAGS (*type) &= ~TYPE_FLAG_STUB;
  2125.     }
  2126.   undef_types_length = 0;
  2127. }
  2128.  
  2129. /* Read a number by which a type is referred to in dbx data,
  2130.    or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
  2131.    Just a single number N is equivalent to (0,N).
  2132.    Return the two numbers by storing them in the vector TYPENUMS.
  2133.    TYPENUMS will then be used as an argument to dbx_lookup_type.  */
  2134.  
  2135. static void
  2136. read_type_number (pp, typenums)
  2137.      register char **pp;
  2138.      register int *typenums;
  2139. {
  2140.   if (**pp == '(')
  2141.     {
  2142.       (*pp)++;
  2143.       typenums[0] = read_number (pp, ',');
  2144.       typenums[1] = read_number (pp, ')');
  2145.     }
  2146.   else
  2147.     {
  2148.       typenums[0] = 0;
  2149.       typenums[1] = read_number (pp, 0);
  2150.     }
  2151. }
  2152.  
  2153. /* Read a dbx type reference or definition;
  2154.    return the type that is meant.
  2155.    This can be just a number, in which case it references
  2156.    a type already defined and placed in type_vector.
  2157.    Or the number can be followed by an =, in which case
  2158.    it means to define a new type according to the text that
  2159.    follows the =.  */
  2160.  
  2161. static
  2162. struct type *
  2163. read_type (pp)
  2164.      register char **pp;
  2165. {
  2166.   register struct type *type = 0;
  2167.   register int n;
  2168.   struct type *type1;
  2169.   int typenums[2];
  2170.   int xtypenums[2];
  2171.   char *tmpc;
  2172.  
  2173.   /* Read type number if present.  The type number may be omitted.
  2174.      for instance in a two-dimensional array declared with type
  2175.      "ar1;1;10;ar1;1;10;4".  */
  2176.   if ((**pp >= '0' && **pp <= '9')
  2177.       || **pp == '(')
  2178.     {
  2179.       read_type_number (pp, typenums);
  2180.       
  2181.       /* Detect random reference to type not yet defined.
  2182.      Allocate a type object but leave it zeroed.  */
  2183.       if (**pp != '=')
  2184.     return dbx_alloc_type (typenums);
  2185.  
  2186.       *pp += 2;
  2187.     }
  2188.   else
  2189.     {
  2190.       /* 'typenums=' not present, type is anonymous.  Read and return
  2191.      the definition, but don't put it in the type vector.  */
  2192.       typenums[0] = typenums[1] = -1;
  2193.       *pp += 1;
  2194.     }
  2195.  
  2196.   switch ((*pp)[-1])
  2197.     {
  2198.     case 'x':
  2199.       {
  2200.     enum type_code code;
  2201.  
  2202.     /* Used to index through file_symbols.  */
  2203.     struct pending *ppt;
  2204.     int i;
  2205.     
  2206.     /* Name including "struct", etc.  */
  2207.     char *type_name;
  2208.     
  2209.     /* Name without "struct", etc.  */
  2210.     char *type_name_only;
  2211.  
  2212.     {
  2213.       char *prefix;
  2214.       char *from, *to;
  2215.       
  2216.       /* Set the type code according to the following letter.  */
  2217.       switch ((*pp)[0])
  2218.         {
  2219.         case 's':
  2220.           code = TYPE_CODE_STRUCT;
  2221.           prefix = "struct ";
  2222.           break;
  2223.         case 'u':
  2224.           code = TYPE_CODE_UNION;
  2225.           prefix = "union ";
  2226.           break;
  2227.         case 'e':
  2228.           code = TYPE_CODE_ENUM;
  2229.           prefix = "enum ";
  2230.           break;
  2231.         default:
  2232.           error ("Bad type cross reference at symnum: %d.", symnum);
  2233.         }
  2234.       
  2235.       to = type_name = (char *)
  2236.         obstack_alloc (symbol_obstack,
  2237.                (strlen (prefix) +
  2238.                 ((char *) index (*pp, ':') - (*pp)) + 1));
  2239.     
  2240.       /* Copy the prefix.  */
  2241.       from = prefix;
  2242.       while (*to++ = *from++)
  2243.         ;
  2244.       to--; 
  2245.     
  2246.       type_name_only = to;
  2247.  
  2248.       /* Copy the name.  */
  2249.       from = *pp + 1;
  2250.       while ((*to++ = *from++) != ':')
  2251.         ;
  2252.       *--to = '\0';
  2253.       
  2254.       /* Set the pointer ahead of the name which we just read.  */
  2255.       *pp = from;
  2256.     
  2257. #if 0
  2258.       /* The following hack is clearly wrong, because it doesn't
  2259.          check whether we are in a baseclass.  I tried to reproduce
  2260.          the case that it is trying to fix, but I couldn't get
  2261.          g++ to put out a cross reference to a basetype.  Perhaps
  2262.          it doesn't do it anymore.  */
  2263.       /* Note: for C++, the cross reference may be to a base type which
  2264.          has not yet been seen.  In this case, we skip to the comma,
  2265.          which will mark the end of the base class name.  (The ':'
  2266.          at the end of the base class name will be skipped as well.)
  2267.          But sometimes (ie. when the cross ref is the last thing on
  2268.          the line) there will be no ','.  */
  2269.       from = (char *) index (*pp, ',');
  2270.  
  2271. /* Change by Bryan Boreham, Kewill, Tue Oct 31 14:53:00 1989.
  2272.    It can be that there is a comma, but it is part of the next section
  2273.    of the stab; i.e. after the next semi-colon. If this is the case,
  2274.    pretend there is no comma.    */
  2275.       {
  2276.         char *semi = (char *) index (*pp, ';');
  2277.         if (semi != 0 && from > semi)
  2278.           from = 0;
  2279.       }
  2280.  
  2281.       if (from)
  2282.         *pp = from;
  2283. #endif /* 0 */
  2284.     }
  2285.  
  2286.     /* Now check to see whether the type has already been declared.  */
  2287.     /* This is necessary at least in the case where the
  2288.        program says something like
  2289.          struct foo bar[5];
  2290.        The compiler puts out a cross-reference; we better find
  2291.        set the length of the structure correctly so we can
  2292.        set the length of the array.  */
  2293.     for (ppt = file_symbols; ppt; ppt = ppt->next)
  2294.       for (i = 0; i < ppt->nsyms; i++)
  2295.         {
  2296.           struct symbol *sym = ppt->symbol[i];
  2297.  
  2298.           if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
  2299.           && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
  2300.           && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
  2301.           && !strcmp (SYMBOL_NAME (sym), type_name_only))
  2302.         {
  2303.           obstack_free (symbol_obstack, type_name);
  2304.           type = SYMBOL_TYPE (sym);
  2305.           return type;
  2306.         }
  2307.         }
  2308.     
  2309.     /* Didn't find the type to which this refers, so we must
  2310.        be dealing with a forward reference.  Allocate a type
  2311.        structure for it, and keep track of it so we can
  2312.        fill in the rest of the fields when we get the full
  2313.        type.  */
  2314.     type = dbx_alloc_type (typenums);
  2315.     TYPE_CODE (type) = code;
  2316.     TYPE_NAME (type) = type_name;
  2317.  
  2318.     TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
  2319.  
  2320.     add_undefined_type (type);
  2321.     return type;
  2322.       }
  2323.  
  2324.     case '0':
  2325.     case '1':
  2326.     case '2':
  2327.     case '3':
  2328.     case '4':
  2329.     case '5':
  2330.     case '6':
  2331.     case '7':
  2332.     case '8':
  2333.     case '9':
  2334.     case '(':
  2335.       (*pp)--;
  2336.       read_type_number (pp, xtypenums);
  2337.       type = *dbx_lookup_type (xtypenums);
  2338.       if (type == 0)
  2339.     type = builtin_type_void;
  2340.       if (typenums[0] != -1)
  2341.     *dbx_lookup_type (typenums) = type;
  2342.       break;
  2343.       
  2344.     case '*':
  2345.     case '&':
  2346. #if 0
  2347.       type1 = read_type (pp);
  2348.       if (TYPE_POINTER_TYPE (type1))
  2349.     {
  2350.       type = TYPE_POINTER_TYPE (type1);
  2351.       if (typenums[0] != -1)
  2352.         *dbx_lookup_type (typenums) = type;
  2353.     }
  2354.       else
  2355.     {
  2356.       type = dbx_alloc_type (typenums);
  2357.       smash_to_pointer_type (type, type1);
  2358.     }
  2359.       break;
  2360. #else
  2361.       type1 = read_type (pp);
  2362.       type = lookup_pointer_type (type1);
  2363.       if (typenums[0] != -1)
  2364.     *dbx_lookup_type (typenums) = type;
  2365.       break;
  2366. #endif
  2367.  
  2368.     case 'f':
  2369. #if 0
  2370.       type1 = read_type (pp);
  2371.       if (TYPE_FUNCTION_TYPE (type1))
  2372.     {
  2373.       type = TYPE_FUNCTION_TYPE (type1);
  2374.       if (typenums[0] != -1)
  2375.         *dbx_lookup_type (typenums) = type;
  2376.     }
  2377.       else
  2378.     {
  2379.       type = dbx_alloc_type (typenums);
  2380.       smash_to_function_type (type, type1);
  2381.     }
  2382.       break;
  2383. #else
  2384.       type1 = read_type (pp);
  2385.       type = lookup_function_type (type1);
  2386.       if (typenums[0] != -1)
  2387.     *dbx_lookup_type (typenums) = type;
  2388.       break;
  2389. #endif
  2390.  
  2391.     case 'r':
  2392.       type = read_range_type (pp, typenums);
  2393.       if (typenums[0] != -1)
  2394.     *dbx_lookup_type (typenums) = type;
  2395.       break;
  2396.  
  2397.     case 'e':
  2398.       type = dbx_alloc_type (typenums);
  2399.       type = read_enum_type (pp, type);
  2400.       *dbx_lookup_type (typenums) = type;
  2401.       break;
  2402.  
  2403.     case 's':
  2404.       type = dbx_alloc_type (typenums);
  2405.       type = read_struct_type (pp, type);
  2406.       break;
  2407.  
  2408.     case 'u':
  2409.       type = dbx_alloc_type (typenums);
  2410.       type = read_struct_type (pp, type);
  2411.       TYPE_CODE (type) = TYPE_CODE_UNION;
  2412.       break;
  2413.  
  2414.     case 'a':
  2415.       /* Define an array type.  */
  2416.       if (*(*pp)++ != 'r')
  2417.     error ("Invalid symbol data: unrecognized type-code `a%c' %s %d.",
  2418.            (*pp)[-1], "at symtab position", symnum);
  2419.  
  2420.       type = dbx_alloc_type (typenums);
  2421.       type = read_array_type (pp, type);
  2422.       break;
  2423.  
  2424.     default:
  2425.       error ("Invalid symbol data: unrecognized type-code `%c' at symtab pos %d.",
  2426.          (*pp)[-1], symnum);
  2427.     }
  2428.  
  2429.   if (type == 0)
  2430.     abort ();
  2431.  
  2432. #if 0
  2433.   /* If this is an overriding temporary alteration for a header file's
  2434.      contents, and this type number is unknown in the global definition,
  2435.      put this type into the global definition at this type numbe.  */
  2436.   if (header_file_prev_index >= 0)
  2437.     {
  2438.       register struct type **tp
  2439.         = explicit_lookup_type (header_file_prev_index, typenums[1]);
  2440.       if (*tp == 0)
  2441.     *tp = type;
  2442.     }
  2443. #endif
  2444.   return type;
  2445. }
  2446.  
  2447. /* This page contains subroutines of read_type.  */
  2448.  
  2449. /* Read the description of a structure (or union type)
  2450.    and return an object describing the type.  */
  2451.  
  2452. static struct type *
  2453. read_struct_type (pp, type)
  2454.      char **pp;
  2455.      register struct type *type;
  2456. {
  2457.   struct nextfield
  2458.     {
  2459.       struct nextfield *next;
  2460.       struct field field;
  2461.     };
  2462.  
  2463.   register struct nextfield *list = 0;
  2464.   struct nextfield *new;
  2465.   int totalsize;
  2466.   char *name;
  2467.   register char *p;
  2468.   int nfields = 0;
  2469.   register int n;
  2470.  
  2471.   TYPE_CODE (type) = TYPE_CODE_STRUCT;
  2472.  
  2473.   /* First comes the total size in bytes.  */
  2474.  
  2475.   TYPE_LENGTH (type) = read_number (pp, 0);
  2476.  
  2477.   /* Now come the fields, as NAME:TYPENUM,BITPOS,BITSIZE; for each one.
  2478.      At the end, we see a semicolon instead of a field.  */
  2479.  
  2480.   while (**pp != ';')
  2481.     {
  2482.       /* Check for and handle cretinous dbx symbol name continuation!  */
  2483.       if (**pp == '\\')
  2484.     *pp = next_symbol_text ();
  2485.  
  2486.       /* Get space to record the next field's data.  */
  2487.       new = (struct nextfield *) alloca (sizeof (struct nextfield));
  2488.       new->next = list;
  2489.       list = new;
  2490.  
  2491.       /* Read the data.  */
  2492.       p = *pp;
  2493.       while (*p != ':') p++;
  2494.       list->field.name = obsavestring (*pp, p - *pp);
  2495.       *pp = p + 1;
  2496.       list->field.type = read_type (pp);
  2497.       if (**pp != ',')
  2498.     error ("Invalid symbol data: bad structure-type format at symtab pos %d.",
  2499.            symnum);
  2500.       (*pp)++;            /* Skip the comma.  */
  2501.       list->field.bitpos = read_number (pp, ',');
  2502.       list->field.bitsize = read_number (pp, ';');
  2503.       /* Detect an unpacked field and mark it as such.
  2504.      dbx gives a bit size for all fields.
  2505.      Note that forward refs cannot be packed,
  2506.      and treat enums as if they had the width of ints.  */
  2507.       if (TYPE_CODE (list->field.type) != TYPE_CODE_INT
  2508.       && TYPE_CODE (list->field.type) != TYPE_CODE_ENUM)
  2509.     list->field.bitsize = 0;
  2510.       if ((list->field.bitsize == 8 * TYPE_LENGTH (list->field.type)
  2511.        || (TYPE_CODE (list->field.type) == TYPE_CODE_ENUM
  2512.            && list->field.bitsize == 8 * TYPE_LENGTH (builtin_type_int)))
  2513.       &&
  2514.       list->field.bitpos % 8 == 0)
  2515.     list->field.bitsize = 0;
  2516.       nfields++;
  2517.     }
  2518.  
  2519.   (*pp)++;            /* Skip the terminating ';'.  */
  2520.  
  2521.   /* Now create the vector of fields, and record how big it is.  */
  2522.  
  2523.   TYPE_NFIELDS (type) = nfields;
  2524.   TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
  2525.                                sizeof (struct field) * nfields);
  2526.  
  2527.   /* Copy the saved-up fields into the field vector.  */
  2528.  
  2529.   for (n = nfields; list; list = list->next)
  2530.     TYPE_FIELD (type, --n) = list->field;
  2531.  
  2532.   return type;
  2533. }
  2534.  
  2535. /* Read a definition of an array type,
  2536.    and create and return a suitable type object.
  2537.    Also creates a range type which represents the bounds of that
  2538.    array.  */
  2539. static struct type *
  2540. read_array_type (pp, type)
  2541.      register char **pp;
  2542.      register struct type *type;
  2543. {
  2544.   struct type *index_type, *element_type, *range_type;
  2545.   int lower, upper;
  2546.   int adjustable = 0;
  2547.  
  2548.   /* Format of an array type:
  2549.      "ar<index type>;lower;upper;<array_contents_type>".  Put code in
  2550.      to handle this.
  2551.  
  2552.      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
  2553.      for these, produce a type like float[][].  */
  2554.  
  2555.   index_type = read_type (pp);
  2556.   if (*(*pp)++ != ';')
  2557.     error ("Invalid symbol data; improper format of array type decl.");
  2558.  
  2559.   if (!(**pp >= '0' && **pp <= '9'))
  2560.     {
  2561.       *pp += 1;
  2562.       adjustable = 1;
  2563.     }
  2564.   lower = read_number (pp, ';');
  2565.  
  2566.   if (!(**pp >= '0' && **pp <= '9'))
  2567.     {
  2568.       *pp += 1;
  2569.       adjustable = 1;
  2570.     }
  2571.   upper = read_number (pp, ';');
  2572.   
  2573.   element_type = read_type (pp);
  2574.  
  2575.   if (adjustable)
  2576.     {
  2577.       lower = 0;
  2578.       upper = -1;
  2579.     }
  2580.  
  2581.   {
  2582.     /* Create range type.  */
  2583.     range_type = (struct type *) obstack_alloc (symbol_obstack,
  2584.                         sizeof (struct type));
  2585.     TYPE_CODE (range_type) = TYPE_CODE_RANGE;
  2586.     TYPE_TARGET_TYPE (range_type) = index_type;
  2587.  
  2588.     /* This should never be needed.  */
  2589.     TYPE_LENGTH (range_type) = sizeof (int);
  2590.  
  2591.     TYPE_NFIELDS (range_type) = 2;
  2592.     TYPE_FIELDS (range_type) =
  2593.       (struct field *) obstack_alloc (symbol_obstack,
  2594.                       2 * sizeof (struct field));
  2595.     TYPE_FIELD_BITPOS (range_type, 0) = lower;
  2596.     TYPE_FIELD_BITPOS (range_type, 1) = upper;
  2597.   }
  2598.  
  2599.   TYPE_CODE (type) = TYPE_CODE_ARRAY;
  2600.   TYPE_TARGET_TYPE (type) = element_type;
  2601.   TYPE_LENGTH (type) = (upper - lower + 1) * TYPE_LENGTH (element_type);
  2602.   TYPE_NFIELDS (type) = 1;
  2603.   TYPE_FIELDS (type) =
  2604.     (struct field *) obstack_alloc (symbol_obstack,
  2605.                     sizeof (struct field));
  2606.   TYPE_FIELD_TYPE (type, 0) = range_type;
  2607.  
  2608.   return type;
  2609. }
  2610.  
  2611. /* Read a definition of an enumeration type,
  2612.    and create and return a suitable type object.
  2613.    Also defines the symbols that represent the values of the type.  */
  2614.  
  2615. static struct type *
  2616. read_enum_type (pp, type)
  2617.      register char **pp;
  2618.      register struct type *type;
  2619. {
  2620.   register char *p;
  2621.   char *name;
  2622.   register long n;
  2623.   register struct symbol *sym;
  2624.   int nsyms = 0;
  2625.   struct pending **symlist;
  2626.   struct pending *osyms, *syms;
  2627.   int o_nsyms;
  2628.  
  2629.   if (within_function)
  2630.     symlist = &local_symbols;
  2631.   else
  2632.     symlist = &file_symbols;
  2633.   osyms = *symlist;
  2634.   o_nsyms = osyms ? osyms->nsyms : 0;
  2635.  
  2636.   /* Read the value-names and their values.
  2637.      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
  2638.      A semicolon or comman instead of a NAME means the end.  */
  2639.   while (**pp && **pp != ';' && **pp != ',')
  2640.     {
  2641.       /* Check for and handle cretinous dbx symbol name continuation!  */
  2642.       if (**pp == '\\')
  2643.     *pp = next_symbol_text ();
  2644.  
  2645.       p = *pp;
  2646.       while (*p != ':') p++;
  2647.       name = obsavestring (*pp, p - *pp);
  2648.       *pp = p + 1;
  2649.       n = read_number (pp, ',');
  2650.       
  2651.       sym = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
  2652.       bzero (sym, sizeof (struct symbol));
  2653.       SYMBOL_NAME (sym) = name;
  2654.       SYMBOL_CLASS (sym) = LOC_CONST;
  2655.       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
  2656.       SYMBOL_VALUE (sym) = n;
  2657.       add_symbol_to_list (sym, symlist);
  2658.       nsyms++;
  2659.     }
  2660.  
  2661.   if (**pp == ';')
  2662.     (*pp)++;            /* Skip the semicolon.  */
  2663.  
  2664.   /* Now fill in the fields of the type-structure.  */
  2665.  
  2666. #ifdef atarist
  2667.   TYPE_LENGTH (type) = gcc_mshort ? sizeof (short) : sizeof (int);
  2668. #else
  2669.   TYPE_LENGTH (type) = sizeof (int);
  2670. #endif
  2671.   TYPE_CODE (type) = TYPE_CODE_ENUM;
  2672.   TYPE_NFIELDS (type) = nsyms;
  2673.   TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field) * nsyms);
  2674.  
  2675.   /* Find the symbols for the values and put them into the type.
  2676.      The symbols can be found in the symlist that we put them on
  2677.      to cause them to be defined.  osyms contains the old value
  2678.      of that symlist; everything up to there was defined by us.  */
  2679.   /* Note that we preserve the order of the enum constants, so
  2680.      that in something like "enum {FOO, LAST_THING=FOO}" we print
  2681.      FOO, not LAST_THING.  */
  2682.  
  2683.   for (syms = *symlist, n = 0; syms; syms = syms->next)
  2684.     {
  2685.       int j = 0;
  2686.       if (syms == osyms)
  2687.     j = o_nsyms;
  2688.       for (; j < syms->nsyms; j++)
  2689.     {
  2690.       struct symbol *sym = syms->symbol[j];
  2691.       SYMBOL_TYPE (sym) = type;
  2692.       TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (sym);
  2693.       TYPE_FIELD_BITPOS (type, n) = 0;
  2694.       TYPE_FIELD_VALUE (type, n) = SYMBOL_VALUE (sym);
  2695.       TYPE_FIELD_BITSIZE (type, n++) = 0;
  2696.     }
  2697.       if (syms == osyms)
  2698.     break;
  2699.     }
  2700.  
  2701.   return type;
  2702. }
  2703.   
  2704. #define    MAX_OF_TYPE(t)    ((1 << (sizeof (t) - 1)) - 1)
  2705. #define MIN_OF_TYPE(t)    (-(1 << (sizeof (t) - 1)))
  2706.  
  2707. static struct type *
  2708. read_range_type (pp, typenums)
  2709.      char **pp;
  2710.      int typenums[2];
  2711. {
  2712.   char *errp = *pp;
  2713.   int rangenums[2];
  2714.   int n2, n3;
  2715.   int self_subrange;
  2716.   struct type *result_type;
  2717.  
  2718.   /* First comes a type we are a subrange of.
  2719.      In C it is usually 0, 1 or the type being defined.  */
  2720.   read_type_number (pp, rangenums);
  2721.   self_subrange = (rangenums[0] == typenums[0] &&
  2722.            rangenums[1] == typenums[1]);
  2723.  
  2724.   /* A semicolon should now follow; skip it.  */
  2725.   if (**pp == ';')
  2726.     (*pp)++;
  2727.  
  2728.   /* The remaining two operands are usually lower and upper bounds
  2729.      of the range.  But in some special cases they mean something else.  */
  2730.   n2 = read_number (pp, ';');
  2731.   n3 = read_number (pp, ';');
  2732.  
  2733.   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
  2734.   if (self_subrange && n2 == 0 && n3 == 0)
  2735.     return builtin_type_void;
  2736.  
  2737.   /* If n3 is zero and n2 is not, we want a floating type,
  2738.      and n2 is the width in bytes.
  2739.  
  2740.      Fortran programs appear to use this for complex types also,
  2741.      and they give no way to distinguish between double and single-complex!
  2742.      We don't have complex types, so we would lose on all fortran files!
  2743.      So return type `double' for all of those.  It won't work right
  2744.      for the complex values, but at least it makes the file loadable.  */
  2745.  
  2746.   if (n3 == 0 && n2 > 0)
  2747.     {
  2748.       if (n2 == sizeof (float))
  2749.     return builtin_type_float;
  2750.       return builtin_type_double;
  2751.     }
  2752.  
  2753.   /* If the upper bound is -1, it must really be an unsigned int.  */
  2754.  
  2755.   else if (n2 == 0 && n3 == -1)
  2756.     {
  2757.     return builtin_type_unsigned_int;
  2758.     }
  2759. #ifdef atarist
  2760.   else if (n2 == -32768 && n3 == 32767 && typenums[1] == 1)
  2761.     {
  2762.       gcc_mshort = 1;
  2763.       return builtin_type_short;
  2764.     }
  2765. #endif
  2766.    
  2767.   /* Special case: char is defined (Who knows why) as a subrange of
  2768.      itself with range 0-127.  */
  2769.   else if (self_subrange && n2 == 0 && n3 == 127)
  2770.     return builtin_type_char;
  2771.  
  2772.   /* Assumptions made here: Subrange of self is equivalent to subrange
  2773.      of int.  */
  2774.   else if (n2 == 0
  2775.        && (self_subrange ||
  2776.            *dbx_lookup_type (rangenums) == 
  2777. #ifdef atarist
  2778.            (gcc_mshort ? builtin_type_short : builtin_type_int)
  2779. #else
  2780.            builtin_type_int
  2781. #endif
  2782.            ))
  2783.     {
  2784.       /* an unsigned type */
  2785. #ifdef LONG_LONG
  2786.       if (n3 == - sizeof (long long))
  2787.     return builtin_type_unsigned_long_long;
  2788. #endif
  2789.       if (n3 == (1 << (8 * sizeof (int))) - 1)
  2790.     return builtin_type_unsigned_int;
  2791.       if (n3 == (1 << (8 * sizeof (short))) - 1)
  2792.     return builtin_type_unsigned_short;
  2793.       if (n3 == (1 << (8 * sizeof (char))) - 1)
  2794.     return builtin_type_unsigned_char;
  2795.     }
  2796. #ifdef LONG_LONG
  2797.   else if (n3 == 0 && n2 == -sizeof (long long))
  2798.     return builtin_type_long_long;
  2799. #endif  
  2800.   else if (n2 == -n3 -1)
  2801.     {
  2802.       /* a signed type */
  2803.       if (n3 == (1 << (8 * sizeof (int) - 1)) - 1)
  2804.     return builtin_type_int;
  2805.       if (n3 == (1 << (8 * sizeof (long) - 1)) - 1)
  2806.      return builtin_type_long;
  2807.       if (n3 == (1 << (8 * sizeof (short) - 1)) - 1)
  2808.     return builtin_type_short;
  2809.       if (n3 == (1 << (8 * sizeof (char) - 1)) - 1)
  2810.     return builtin_type_char;
  2811.     }
  2812.  
  2813.   /* We have a real range type on our hands.  Allocate space and
  2814.      return a real pointer.  */
  2815.  
  2816.   /* At this point I don't have the faintest idea how to deal with
  2817.      a self_subrange type; I'm going to assume that this is used
  2818.      as an idiom, and that all of them are special cases.  So . . .  */
  2819.   if (self_subrange)
  2820.     error ("Type defined as subrange of itself.");
  2821.  
  2822.   result_type = (struct type *) obstack_alloc (symbol_obstack,
  2823.                            sizeof (struct type));
  2824.   bzero (result_type, sizeof (struct type));
  2825.  
  2826.   TYPE_TARGET_TYPE (result_type) = (self_subrange ?
  2827.                     builtin_type_int :
  2828.                     *dbx_lookup_type(rangenums));
  2829.  
  2830.   /* We have to figure out how many bytes it takes to hold this
  2831.      range type.  I'm going to assume that anything that is pushing
  2832.      the bounds of a long was taken care of above.  */
  2833.   if (n2 >= MIN_OF_TYPE(char) && n3 <= MAX_OF_TYPE(char))
  2834.     TYPE_LENGTH (result_type) = 1;
  2835.   else if (n2 >= MIN_OF_TYPE(short) && n3 <= MAX_OF_TYPE(short))
  2836.     TYPE_LENGTH (result_type) = sizeof (short);
  2837.   else if (n2 >= MIN_OF_TYPE(int) && n3 <= MAX_OF_TYPE(int))
  2838.     TYPE_LENGTH (result_type) = sizeof (int);
  2839.   else if (n2 >= MIN_OF_TYPE(long) && n3 <= MAX_OF_TYPE(long))
  2840.     TYPE_LENGTH (result_type) = sizeof (long);
  2841.   else
  2842. #ifdef atarist
  2843.     error ("Ranged type doesn't fit within known sizes.\n\
  2844. On an atariST this is most likely due to\n\
  2845. objects compiled with the \"-mshort\" option to gcc.\n\
  2846. Please re-try by specifying the \"-mshort\" option on the gdb command line.\n\
  2847. n2 == %d, n3 == %d\n", n2,n3);
  2848. #else
  2849.     error ("Ranged type doesn't fit within known sizes.");
  2850. #endif
  2851.  
  2852.   TYPE_LENGTH (result_type) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type));
  2853.   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
  2854.   TYPE_NFIELDS (result_type) = 2;
  2855.   TYPE_FIELDS (result_type) =
  2856.     (struct field *) obstack_alloc (symbol_obstack,
  2857.                     2 * sizeof (struct field));
  2858.   bzero (TYPE_FIELDS (result_type), 2 * sizeof (struct field));
  2859.   TYPE_FIELD_BITPOS (result_type, 0) = n2;
  2860.   TYPE_FIELD_BITPOS (result_type, 1) = n3;
  2861.  
  2862.   return result_type;
  2863. }
  2864.  
  2865. /* Read a number from the string pointed to by *PP.
  2866.    The value of *PP is advanced over the number.
  2867.    If END is nonzero, the character that ends the
  2868.    number must match END, or an error happens;
  2869.    and that character is skipped if it does match.
  2870.    If END is zero, *PP is left pointing to that character.  */
  2871.  
  2872. static long
  2873. read_number (pp, end)
  2874.      char **pp;
  2875.      int end;
  2876. {
  2877.   register char *p = *pp;
  2878.   register long n = 0;
  2879.   register int c;
  2880.   int sign = 1;
  2881.  
  2882.   /* Handle an optional leading minus sign.  */
  2883.  
  2884.   if (*p == '-')
  2885.     {
  2886.       sign = -1;
  2887.       p++;
  2888.     }
  2889.  
  2890.   /* Read the digits, as far as they go.  */
  2891.  
  2892.   while ((c = *p++) >= '0' && c <= '9')
  2893.     {
  2894.       n *= 10;
  2895.       n += c - '0';
  2896.     }
  2897.   if (end)
  2898.     {
  2899.       if (c != end)
  2900.     error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
  2901.     }
  2902.   else
  2903.     --p;
  2904.  
  2905.   *pp = p;
  2906.   return n * sign;
  2907. }
  2908. #ifdef atarist
  2909. set_gcc_mshort()
  2910. {
  2911.    printf_filtered("Was %d\n", gcc_mshort);
  2912.     gcc_mshort = 1;
  2913. }
  2914. #endif
  2915.  
  2916. void
  2917. initialize_dbxread ()
  2918. {
  2919.   symfile = 0;
  2920.  
  2921.   undef_types_allocated = 20;
  2922.   undef_types_length = 0;
  2923.   undef_types = (struct type **) xxmalloc (undef_types_allocated *
  2924.                       sizeof (struct type *));
  2925.   add_com ("symbol-file", class_files, symbol_file_command,
  2926.        "Load symbol table (in dbx format) from executable file FILE.");
  2927. #ifdef atarist
  2928.   add_com ("gcc-mshort", class_files, set_gcc_mshort,
  2929.     "Inform GDB that your programs has 16 bit integer defaults");
  2930. #endif
  2931. }
  2932. #endif /* READ_DBX_FORMAT */
  2933.